diff --git a/app/models/application_question.rb b/app/models/application_question.rb
index 0f147948..41e0d10c 100644
--- a/app/models/application_question.rb
+++ b/app/models/application_question.rb
@@ -21,11 +21,13 @@ def initialize(questions_params)
   # == Scopes ===============================================================
   # == Validations ==========================================================
 
+  # nb: attribute can be nil, so safe navigation operator is necessary with #include?
+
   def boolean? = type.eql?("boolean")
   def checkbox? = type.eql?("checkbox")
-  def cover_letter? = attribute.include?("cover_letter")
+  def cover_letter? = attribute&.include?("cover_letter")
   def input? = type.eql?("input") || type.eql?("education_input")
-  def linkedin_related? = attribute.include?('linkedin')
+  def linkedin_related? = attribute&.include?('linkedin')
   def multi_select? = type.eql?("multi_select")
   def radiogroup? = type.eql?("radiogroup")
   def resume? = attribute.eql?("resume")
diff --git a/app/models/concerns/ats/bamboohr/application_fields.rb b/app/models/concerns/ats/bamboohr/application_fields.rb
index 3bf17b16..2f246925 100644
--- a/app/models/concerns/ats/bamboohr/application_fields.rb
+++ b/app/models/concerns/ats/bamboohr/application_fields.rb
@@ -1,203 +1,9 @@
 module Ats
   module Bamboohr
     module ApplicationFields
-      def get_application_question_set(_job, _data)
-        p "Getting BambooHR application criteria"
-
-        # TODO : implement new application_question_structure structure
-        # job.application_question_set = build_application_question_set_from(data['formFields'])
-        []
+      def get_application_question_set(job, data)
+        Importer::GetBambooFields.call(job, data)
       end
-
-      private
-
-      def build_application_question_set_from(fields)
-        attributes = {}
-
-        fields.each do |locator, details|
-          field = details.instance_of?(Array) ? build_additional_field(details) : build_core_field(locator, details)
-          attributes.merge!(field)
-        rescue StandardError => e
-          p "Error building application criteria: #{e.message}"
-          {}
-        end
-
-        return attributes
-      end
-
-      def build_core_field(locator, data)
-        name, details = CORE_FIELDS.find { |_, attributes| attributes[:locators] == locator }
-        {
-          name => details.merge(
-            required: data['isRequired'],
-            options: data['options']&.map { |option| option['text'] }
-          ).compact
-        }
-      end
-
-      def build_additional_field(data)
-        data.inject({}) do |question_set, field|
-          name, interaction, options = fetch_field_attributes(field)
-          question_set.merge!(
-            name => {
-              interaction:,
-              label: field['question'],
-              locators: field['id'],
-              required: field['isRequired'],
-              options:
-            }.compact
-          )
-        end
-      end
-
-      def fetch_field_attributes(field)
-        name = field['question'].downcase.gsub(' ', '_').gsub(/[^a-z0-9_-]/, '')
-        options = field['options']&.map { |option| option['text'] } unless field['options'].blank?
-        interaction = FIELD_TYPES[field['type']]
-        if interaction == :boolean
-          options ||= ['Yes', 'No']
-          interaction = :select
-        end
-        [name, interaction, options]
-      end
-
-      FIELD_TYPES = {
-        'short' => :input,
-        'long' => :input,
-        'checkbox' => :boolean,
-        'yes_no' => :boolean
-      }
-
-      CORE_FIELDS = {
-        first_name: {
-          interaction: :input,
-          locators: 'firstName',
-          label: 'First Name',
-          core_field: true
-        },
-        last_name: {
-          interaction: :input,
-          locators: 'lastName',
-          label: 'Last Name',
-          core_field: true
-        },
-        email: {
-          interaction: :input,
-          locators: 'email',
-          label: 'Email',
-          core_field: true
-        },
-        phone_number: {
-          interaction: :input,
-          locators: 'phone',
-          label: 'Phone',
-          core_field: true
-        },
-        address: {
-          interaction: :input,
-          locators: 'streetAddress',
-          label: 'Address',
-          core_field: true
-        },
-        city: {
-          interaction: :input,
-          locators: 'city',
-          label: 'City',
-          core_field: true
-        },
-        state: {
-          interaction: :select,
-          locators: 'state',
-          label: 'State',
-          core_field: true
-        },
-        post_code: {
-          interaction: :input,
-          locators: 'zip',
-          label: 'ZIP',
-          core_field: true
-        },
-        country: {
-          interaction: :input,
-          locators: 'countryId',
-          label: 'Country',
-          core_field: true
-        },
-        website_url: {
-          interaction: :input,
-          locators: 'websiteUrl',
-          label: 'Website, Blog, or Portfolio',
-          core_field: true
-        },
-        linkedin_url: {
-          interaction: :input,
-          locators: 'linkedinUrl',
-          label: 'LinkedIn Profile URL',
-          core_field: true
-        },
-        cover_letter: {
-          interaction: :upload,
-          locators: 'coverLetterFileId',
-          label: 'Cover Letter',
-          core_field: true
-        },
-        resume: {
-          interaction: :upload,
-          locators: 'resumeFileId',
-          label: 'Resume',
-          core_field: true
-        },
-        education_level: {
-          interaction: :select,
-          locators: 'educationLevelId',
-          label: 'Highest Education Obtained',
-          core_field: true
-        },
-        education_school: {
-          interaction: :input,
-          locators: 'educationInstitutionName',
-          label: 'College/University',
-          core_field: true
-        },
-        date_available: {
-          interaction: :date,
-          locators: 'dateAvailable',
-          label: 'Date Available',
-          core_field: true
-        },
-        desired_pay: {
-          interaction: :input,
-          locators: 'desiredPay',
-          label: 'Desired Pay',
-          core_field: true
-        },
-        referred_by: {
-          interaction: :input,
-          locators: 'referredBy',
-          label: 'Who referred you for this position?',
-          core_field: true
-        },
-        gender: {
-          interaction: :select,
-          locators: 'genderId',
-          label: 'Gender'
-        },
-        ethnicity: {
-          interaction: :select,
-          locators: 'ethnicityId',
-          label: 'Ethnicity'
-        },
-        disability: {
-          interaction: :select,
-          locators: 'disabilityId',
-          label: 'Disability'
-        },
-        veteran_status: {
-          interaction: :select,
-          locators: 'veteranStatusId',
-          label: 'Veteran Status'
-        }
-      }
     end
   end
 end
diff --git a/app/services/applier/ashby_form_filler.rb b/app/services/applier/ashby_form_filler.rb
index f7ba4c2c..9125051e 100644
--- a/app/services/applier/ashby_form_filler.rb
+++ b/app/services/applier/ashby_form_filler.rb
@@ -48,7 +48,6 @@ def sample_payload
       {
         user_fullname: 'John Smith',
         apply_url: 'https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4',
-        form_locator: '#form',
         fields: [
           {
             locator: '_systemfield_name',
@@ -88,7 +87,6 @@ def multiverse_payload
       {
         user_fullname: 'Jean-Jacques Rousseau',
         apply_url: 'https://jobs.ashbyhq.com/multiverse/69afde82-dad8-4923-937e-a8d7f0551db4',
-        form_locator: '#form',
         fields: [
           {
             locator: '_systemfield_name',
@@ -103,7 +101,7 @@ def multiverse_payload
           {
             locator: '_systemfield_resume',
             interaction: :upload,
-            value: File.open('public/Obretetskiy_cv.pdf')
+            value: 'https://res.cloudinary.com/dzpupuayh/image/upload/v1/development/nd4p85sryuu40oz77n0bhs29b2sz.pdf?_a=BACCd2Bn'
           },
           {
             locator: '1e68a3c6-1709-40e3-ad14-379c7f5bb56d',
diff --git a/app/services/applier/bamboo_form_filler.rb b/app/services/applier/bamboo_form_filler.rb
new file mode 100644
index 00000000..a5515a41
--- /dev/null
+++ b/app/services/applier/bamboo_form_filler.rb
@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Applier
+  class BambooFormFiller < FormFiller
+    def initialize(payload = sample_payload)
+      super
+    end
+
+    private
+
+    def application_form = '#careerApplicationForm'
+
+    def attach_file_to_application
+      find("input[name='#{@locator}']")
+        .sibling('div')
+        .find('input')
+        .attach_file(@filepath)
+    end
+
+    def click_submit_button
+      sleep 2
+      p "I didn't actually submit the application."
+    end
+
+    def expand_select_menu = @hidden_select_field.sibling('div').click
+
+    def handle_select
+      @hidden_select_field = find("select[name='#{@locator}']")
+      return if option_prefilled?
+
+      super
+    end
+
+    def option_prefilled? = @hidden_select_field.has_css?("option[value='#{@value}']")
+
+    def select_option = page.document.find_by_id(@value, visible: true)
+
+    def sample_payload
+      {
+        user_fullname: 'John Smith',
+        apply_url: 'https://resurgo.bamboohr.com/careers/95',
+        fields: [
+          {
+            locator: 'firstName',
+            interaction: :input,
+            value: 'John'
+          },
+          {
+            locator: 'lastName',
+            interaction: :input,
+            value: 'Smith'
+          },
+          {
+            locator: 'email',
+            interaction: :input,
+            value: 'j.smith@example.com'
+          },
+          {
+            locator: 'phone',
+            interaction: :input,
+            value: '(555) 555-5555'
+          },
+          {
+            locator: 'resumeFileId',
+            interaction: :upload,
+            value: 'https://res.cloudinary.com/dzpupuayh/image/upload/v1/development/nd4p85sryuu40oz77n0bhs29b2sz.pdf?_a=BACCd2Bn'
+          },
+          {
+            locator: 'streetAddress',
+            interaction: :input,
+            value: 'Shoreditch Stables North, 138 Kingsland Rd'
+          },
+          {
+            locator: 'city',
+            interaction: :input,
+            value: 'London'
+          },
+          {
+            locator: 'state',
+            interaction: :select,
+            value: '370'
+          },
+          {
+            locator: 'zip',
+            interaction: :input,
+            value: 'E2 8DY'
+          },
+          {
+            locator: 'countryId',
+            interaction: :select,
+            value: '222'
+          },
+          {
+            locator: 'dateAvailable',
+            interaction: :input,
+            value: '31072024'
+          },
+          {
+            locator: 'referredBy',
+            interaction: :input,
+            value: 'Sergey Brin'
+          },
+          {
+            locator: 'customQuestions[1965]',
+            interaction: :input,
+            value: 'A little birdie told me.'
+          },
+          {
+            locator: 'customQuestions[1966]',
+            interaction: :input,
+            value: 'No, no, never applied to you before. Why?'
+          },
+          {
+            locator: 'customQuestions[1967]',
+            interaction: :input,
+            value: 'Oh gosh, where to start? Everything. And nothing. Nothing at all, really. Nothing really worth mentioning.'
+          },
+          {
+            locator: 'customQuestions[1968]',
+            interaction: :input,
+            value: "I like to be good. I don't like to have to ask for forgiveness. And I am good; I don't do a lot of things that are bad, I try and do nothing that's bad. I have a great relationship with God."
+          },
+          {
+            locator: 'customQuestions[1969]',
+            interaction: :input,
+            value: "I have a very diverse background. I'm a gay, lesbian, transgender woman of mixed black and brown background and neurodiverse and disabled. I'm part dolphin."
+          },
+          {
+            locator: 'customQuestions[1970]',
+            interaction: :input,
+            value: "Because of my condition I'm unable to work more than 20 minutes a week."
+          },
+          {
+            locator: 'customQuestions[1971]',
+            interaction: :input,
+            value: "It sounds like you're attempting to discriminate against me because of my condition."
+          },
+          {
+            locator: 'customQuestions[1972]',
+            interaction: :input,
+            value: 'No no, not working atm'
+          },
+          {
+            locator: 'customQuestions[1973]',
+            interaction: :input,
+            value: "I have a legal right to work, although I don't like to."
+          },
+          {
+            locator: 'customQuestions[1974]',
+            interaction: :input,
+            value: "Let's discuss."
+          },
+          {
+            locator: 'customQuestions[1975]',
+            interaction: :boolean,
+            value: true
+          }
+          # {
+          #   locator: '#cvFileId',
+          #   interaction: :upload,
+          #   value: File.open('public/Obretetskiy_cv.pdf')
+          # },
+          # {
+          #   locator: 'motivationLetter',
+          #   interaction: :input,
+          #   value: 'Thank you for considering my application. It really is an honor to apply to your company. Please hire me. I would like to work here very much. I promise to work very very hard and always get along well with my coworkers.'
+          # }
+        ]
+      }
+    end
+  end
+end
diff --git a/app/services/applier/form_filler.rb b/app/services/applier/form_filler.rb
index e4d314c0..762cbe74 100644
--- a/app/services/applier/form_filler.rb
+++ b/app/services/applier/form_filler.rb
@@ -38,13 +38,15 @@ def process
     def application_form = '#form'
 
     def apply_button
-      find(:css, 'button, a', text: /apply/i, match: :first)
+      find(:css, 'button, a', text: /apply/i, match: :first, visible: true, wait: 8)
     end
 
     def attach_file_to_application
       attach_file(@locator, @filepath)
     end
 
+    def boolean_field = find(:css, "label[for='#{@locator}']")
+
     def click_apply_button
       apply_button.click
     end
@@ -79,6 +81,8 @@ def fill_in_field(field)
       p e.message
     end
 
+    def handle_boolean = (boolean_field.click if @value)
+
     def handle_input
       verify_input { fill_in(@locator, with: @value) }
     end
@@ -93,12 +97,19 @@ def handle_multi_select
       end
     end
 
+    def handle_select
+      expand_select_menu
+      select_option.click
+    end
+
     def handle_upload
-      @value.instance_of?(String) ? doc_tmp_file : pdf_tmp_file
+      url?(@value) ? pdf_tmp_file : doc_tmp_file
       attach_file_to_application
     end
 
     def pdf_tmp_file
+      uri = URI.parse(@value)
+      @value = Net::HTTP.get_response(uri).body # TODO: replace with CheckUrlIsValid#get?
       @filepath = Rails.root.join("tmp", "Resume - #{unique_string}.pdf")
       File.binwrite(@filepath, @value)
     end
@@ -121,6 +132,12 @@ def unique_string
       "#{@user_fullname}_#{timestamp}"
     end
 
+    def url?(string)
+      URI(string).present?
+    rescue
+      false
+    end
+
     def verify_input(retries = 3)
       returned_value = yield.value
       raise Applier::IncorrectInputError unless returned_value == @value
diff --git a/app/services/applier/greenhouse_form_filler.rb b/app/services/applier/greenhouse_form_filler.rb
index 6c37f4a8..252c6a84 100644
--- a/app/services/applier/greenhouse_form_filler.rb
+++ b/app/services/applier/greenhouse_form_filler.rb
@@ -2,11 +2,6 @@
 
 module Applier
   class GreenhouseFormFiller < FormFiller
-    def initialize(payload = sample_payload)
-      super
-      convert_locators
-    end
-
     private
 
     def application_form = '#application-form'
@@ -16,48 +11,36 @@ def click_submit_button
       p "I didn't actually submit the application."
     end
 
-    def click_and_answer_follow_up(checkbox, follow_up_value)
-      checkbox.click
-      return unless follow_up_value
-
-      find(:css, "input[type='text']", focused: true).set(follow_up_value)
+    def click_and_answer_follow_up(value)
+      value, follow_up_value = value if value.is_a?(Array)
+      find(:css, "div[role='option']", text: value.strip).click
+      find_by_id("#{@locator}-freeform").set(follow_up_value) if follow_up_value
     end
 
-    def convert_locators
-      @fields.each do |field|
-        locator = field[:locator]
-        field[:locator] = "question_#{locator}" if numerical?(locator)
-      end
+    def demographic_label = find_by_id("#{@locator}-label")
+
+    def expand_demographic_select_menu
+      demographic_label.sibling('div').first('div div div').click
     end
 
     def expand_select_menu = find_by_id(@locator).click
 
     def handle_demographic_question
-      parent = find(:css, "input[type='hidden'][value='#{@locator}']")
-               .ancestor('div', class: 'demographic_question')
-      within parent do
-        @value.each do |value|
-          value, follow_up_value = value if value.is_a?(Array)
-          checkbox = find(:css, "input[type='checkbox'][value='#{value}']")
-          click_and_answer_follow_up(checkbox, follow_up_value)
-        end
-      end
-    end
-
-    def handle_multi_select
       @value.each do |value|
-        find(:css, "input[type='checkbox'][value='#{value}'][set='#{@locator}']").click
+        expand_demographic_select_menu
+        click_and_answer_follow_up(value)
       end
     end
 
-    def handle_select
+    def handle_demographic_select
       expand_select_menu
-      select_option.click
+      click_and_answer_follow_up(@value)
     end
 
-    def handle_upload
-      pdf_tmp_file
-      attach_file_to_application
+    def handle_multi_select
+      @value.each do |value|
+        find(:css, "input[type='checkbox'][value='#{value}'][name='#{@locator}']").click
+      end
     end
 
     def hidden_element
@@ -66,12 +49,6 @@ def hidden_element
 
     def numerical?(string) = string.to_i.positive?
 
-    def pdf_tmp_file
-      uri = URI.parse(@value)
-      @value = Net::HTTP.get_response(uri).body
-      super
-    end
-
     def select_option = find("#react-select-#{@locator}-option-#{@value}")
 
     def sample_payload
@@ -104,11 +81,11 @@ def sample_payload
             interaction: :upload,
             value: 'https://res.cloudinary.com/dzpupuayh/image/upload/v1/development/nd4p85sryuu40oz77n0bhs29b2sz.pdf?_a=BACCd2Bn'
           },
-          # {
-          #   locator: 'button[aria-describedby="cover_letter-allowable-file-types"]',
-          #   interaction: :upload,
-          #   value: 'Thank you for considering my application. It really is an honor to apply to your company. Please hire me. I would like to work here very much. I promise to work very very hard and always get along well with my coworkers.'
-          # },
+          {
+            locator: 'cover_letter',
+            interaction: :upload,
+            value: 'Thank you for considering my application. It really is an honor to apply to your company. Please hire me. I would like to work here very much. I promise to work very very hard and always get along well with my coworkers.'
+          },
           {
             locator: '48034254',
             interaction: :input,
@@ -168,11 +145,10 @@ def sample_payload
       }
     end
 
-    def codepath_payload
-      # old format
+    def cleoai_payload
       {
         user_fullname: 'John Smith',
-        apply_url: 'https://boards.greenhouse.io/codepath/jobs/4035988007',
+        apply_url: 'https://job-boards.greenhouse.io/cleoai/jobs/7552121002',
         fields: [
           {
             locator: 'first_name',
@@ -195,74 +171,84 @@ def codepath_payload
             value: '(555) 555-5555'
           },
           {
-            locator: "button[aria-describedby='resume-allowable-file-types']",
+            locator: 'resume',
             interaction: :upload,
-            value: File.open('public/Obretetskiy_cv.pdf')
+            value: 'https://res.cloudinary.com/dzpupuayh/image/upload/v1/development/nd4p85sryuu40oz77n0bhs29b2sz.pdf?_a=BACCd2Bn'
           },
           {
-            locator: 'button[aria-describedby="cover_letter-allowable-file-types"]',
+            locator: 'cover_letter',
             interaction: :upload,
             value: 'Thank you for considering my application. It really is an honor to apply to your company. Please hire me. I would like to work here very much. I promise to work very very hard and always get along well with my coworkers.'
           },
           {
-            locator: '4159819007',
+            locator: 'question_28496729002',
             interaction: :input,
             value: 'https://www.linkedin.com/in/my_profile'
           },
           {
-            locator: '4159820007',
+            locator: 'question_28496730002',
             interaction: :input,
-            value: 'Would be really cool and fun.'
+            value: 'Gosh, it would be really cool and fun.'
           },
           {
-            locator: '4179768007',
-            interaction: :input,
-            value: 'So I helped to build this thing. It was a lot of work! Phew! And you know, it all went pretty well.'
+            locator: 'question_28496731002',
+            interaction: :select,
+            value: '0'
           },
           {
-            locator: '4159821007',
-            interaction: :select,
-            value: '1'
+            locator: 'question_28496732002',
+            interaction: :input,
+            value: '£1,000,000'
           },
           {
-            locator: '4782743007',
-            interaction: :select,
-            value: '6001300007'
+            locator: 'question_28496733002[]',
+            interaction: :multi_select,
+            value: ['176762294002']
           },
           {
-            locator: '6561969007',
-            interaction: :input,
-            value: 'John Quincy Adams'
+            locator: 'question_28496734002[]',
+            interaction: :multi_select,
+            value: ['176762295002', '176762303002', '176762307002']
           },
           {
-            locator: '4006277007',
+            locator: '4000100002',
             interaction: :demographic_question,
-            value: ['4037604007', '4037606007', ['4037607007', 'The Ever-Evolving Enigma Embracing Every Embodiment']]
+            value: ['Man', 'Woman', ['I self describe as', 'The Ever-Evolving Enigma Embracing Every Embodiment']]
           },
           {
-            locator: '4006278007',
+            locator: '4000101002',
             interaction: :demographic_question,
-            value: ['4037610007', '4037611007', '4037612007', '4037614007', '4037617007', ['4037618007', 'diverse']]
+            value: ['White', 'Mixed or Multiple ethnic groups', 'Asian', ['Other', 'Tiger']]
           },
           {
-            locator: '4006279007',
+            locator: '4000102002',
             interaction: :demographic_question,
-            value: ['4037622007', '4037624007', '4037625007', '4037627007']
+            value: ['18-24 years old', '25-34 years old', '35-44 years old']
           },
           {
-            locator: '4006280007',
-            interaction: :demographic_question,
-            value: [['4037630007', 'Sometimes.']]
+            locator: '4000862002',
+            interaction: :demographic_select,
+            value: ['Other - please specify', 'Asexual, pansexual and furry']
           },
           {
-            locator: '4006281007',
-            interaction: :demographic_question,
-            value: ['4037632007']
+            locator: '4000863002',
+            interaction: :demographic_select,
+            value: ['Yes ', 'I got a monkey.']
           },
           {
-            locator: '4006282007',
-            interaction: :demographic_question,
-            value: [['4037638007', "You can't handle the truth!"]]
+            locator: '4000864002',
+            interaction: :demographic_select,
+            value: ['Yes', 'I got a rash.']
+          },
+          {
+            locator: '4000865002',
+            interaction: :demographic_select,
+            value: 'Selective Grammar School'
+          },
+          {
+            locator: '4024833002',
+            interaction: :demographic_select,
+            value: "Other such as: retired, this question does not apply to me, I don’t know."
           }
         ]
       }
diff --git a/app/services/importer/get_api_fields.rb b/app/services/importer/get_api_fields.rb
index 14098dbb..515b3077 100644
--- a/app/services/importer/get_api_fields.rb
+++ b/app/services/importer/get_api_fields.rb
@@ -68,7 +68,6 @@ def core_section_title = 'Main application'
 
     def create_question
       {
-        attribute: generate_attribute_from_label(question_label),
         required: question_required?,
         label: question_label,
         description: question_description,
@@ -102,12 +101,19 @@ def fetch_question_fields
 
     def fetch_questions = send(:"#{@section}_questions")
 
-    def generate_attribute_from_label(label, max_attribute_length = 60)
-      first_question_mark = label.index('?')
-      max_length = [first_question_mark, max_attribute_length].compact.min
-      label.slice(..max_length).downcase.gsub('/', ' ').gsub(/[^a-z ]/, '').strip.gsub(/ +/, '_')
+    def find_insertion_index(base_qs, method, target)
+      target_index = base_qs.find_index { |q| question_id(q) == target }
+      return base_qs.size unless target_index
+
+      method == :insert_after ? target_index + 1 : target_index
     end
 
+    # def generate_attribute_from_label(label, max_attribute_length = 60)
+    #   first_question_mark = label.index('?')
+    #   max_length = [first_question_mark, max_attribute_length].compact.min
+    #   label.slice(..max_length).downcase.gsub('/', ' ').gsub(/[^a-z ]/, '').strip.gsub(/ +/, '_')
+    # end
+
     def generate_section
       @section_fields = {
         build_type: @data_source,
@@ -118,21 +124,14 @@ def generate_section
       }
     end
 
-    def log_and_return_fields
-      puts pretty_generate(@fields)
-      @fields
-    end
-
     def insert_questions(base_qs, qs_to_insert, method, target)
       index = find_insertion_index(base_qs, method, target)
       base_qs[0...index] + qs_to_insert + base_qs[index..]
     end
 
-    def find_insertion_index(base_qs, method, target)
-      target_index = base_qs.find_index { |q| question_id(q) == target }
-      return base_qs.size unless target_index
-
-      method == :insert_after ? target_index + 1 : target_index
+    def log_and_return_fields
+      puts pretty_generate(@fields)
+      @fields
     end
 
     def standardize_type(type) = @types[type] || type
diff --git a/app/services/importer/get_bamboo_fields.rb b/app/services/importer/get_bamboo_fields.rb
new file mode 100644
index 00000000..e6678a41
--- /dev/null
+++ b/app/services/importer/get_bamboo_fields.rb
@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+module Importer
+  class GetBambooFields < GetApiFields
+    def initialize(job, data)
+      options = {
+        data_source: :api,
+        sections: %i[core additional],
+        standard_fields: STANDARD_FIELDS,
+        types: TYPES
+      }
+
+      super(job, data, options)
+    end
+
+    private
+
+    def additional_questions = @data.dig('formFields', 'customQuestions') || []
+
+    def additional_section_description = nil
+
+    def additional_section_title = 'Additional questions'
+
+    def convert_custom_questions_id(value)
+      "customQuestions[#{value}]"
+    end
+
+    def core_questions
+      @data['formFields'].map { |e| { id: e.first }.merge(e.second) if e.second.is_a?(Hash) }.compact
+    end
+
+    def create_question = deep_merge(core_details, question_details)
+
+    def deep_merge(core, question)
+      core.merge(question) { |key, a, b| key == :fields ? [a[0].merge(b[0])] : a }
+    end
+
+    def field_id = question_id(@field)
+
+    def field_max_length = nil
+
+    def field_options = @field['options'] || []
+
+    def field_type = @field['type']
+
+    def option_id(option) = option['id']
+
+    def option_label(option) = option['text']
+
+    def option_free_form(_option) = nil
+
+    def option_decline_to_answer(_option) = nil
+
+    def question_fields = [@question]
+
+    def question_details
+      {
+        required: question_required?,
+        label: question_label,
+        fields: fetch_question_fields
+      }
+    end
+
+    def question_id(question) = question[:id] || convert_custom_questions_id(question['id'])
+
+    def question_label = @question['question']
+
+    def question_required? = @question['isRequired']
+
+    EDUCATION_FIELDS = [
+      'school',
+      'degree',
+      'discipline',
+      'start_date',
+      'end_date'
+    ]
+
+    STANDARD_FIELDS = {
+      'firstName' => {
+        label: 'First Name',
+        attribute: :first_name,
+        fields: [
+          {
+            id: 'firstName',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'lastName' => {
+        attribute: :last_name,
+        label: 'Last Name',
+        fields: [
+          {
+            id: 'lastName',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'email' => {
+        attribute: :email,
+        label: 'Email',
+        fields: [
+          {
+            id: 'email',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'phone' => {
+        attribute: :phone_number,
+        label: 'Phone',
+        fields: [
+          {
+            id: 'phone',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'streetAddress' => {
+        attribute: :address_applicant,
+        label: 'Address',
+        fields: [
+          {
+            id: 'streetAddress',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'city' => {
+        attribute: :city_applicant,
+        label: 'City',
+        fields: [
+          {
+            id: 'city',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'state' => {
+        attribute: :county_applicant,
+        label: 'County', # this will vary by country
+        fields: [
+          {
+            id: 'state',
+            type: :select
+          }
+        ]
+      },
+      'zip' => {
+        attribute: :postcode_applicant,
+        label: 'Postcode', # this will vary by country
+        fields: [
+          {
+            id: 'zip',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'countryId' => {
+        attribute: :country_applicant,
+        label: 'Country',
+        fields: [
+          {
+            id: 'countryId',
+            type: :input
+          }
+        ]
+      },
+      'websiteUrl' => {
+        attribute: :website_url,
+        label: 'Website, Blog, or Portfolio',
+        fields: [
+          {
+            id: 'websiteUrl',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'linkedinUrl' => {
+        attribute: :linkedin_url,
+        label: 'LinkedIn Profile URL',
+        fields: [
+          {
+            id: 'linkedinUrl',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'coverLetterFileId' => {
+        attribute: :cover_letter,
+        label: 'Cover Letter',
+        fields: [
+          {
+            id: 'coverLetterFileId',
+            type: :upload,
+            options: []
+          }
+        ]
+      },
+      'resumeFileId' => {
+        attribute: :resume,
+        label: 'Resume',
+        fields: [
+          {
+            id: 'resumeFileId',
+            type: :upload,
+            options: []
+          }
+        ]
+      },
+      'educationLevelId' => {
+        attribute: :education_level_applicant,
+        label: 'Highest Education Obtained',
+        fields: [
+          {
+            id: 'educationLevelId',
+            type: :select,
+            options: []
+          }
+        ]
+      },
+      'educationInstitutionName' => {
+        attribute: :school_applicant,
+        label: 'College/University',
+        fields: [
+          {
+            id: 'educationInstitutionName',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'dateAvailable' => {
+        attribute: :date_available,
+        label: 'Date Available',
+        fields: [
+          {
+            id: 'dateAvailable',
+            type: :date,
+            options: []
+          }
+        ]
+      },
+      'desiredPay' => {
+        attribute: :desired_pay,
+        label: 'Desired Pay',
+        fields: [
+          {
+            id: 'desiredPay',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'referredBy' => {
+        attribute: :referred_by,
+        label: 'Who referred you for this position?',
+        fields: [
+          {
+            id: 'referredBy',
+            type: :input,
+            options: []
+          }
+        ]
+      },
+      'genderId' => {
+        attribute: :gender,
+        label: 'Gender',
+        fields: [
+          {
+            id: 'genderId',
+            type: :select,
+            options: []
+          }
+        ]
+      },
+      'ethnicityId' => {
+        attribute: :ethnicity,
+        label: 'Ethnicity',
+        fields: [
+          {
+            id: 'ethnicityId',
+            type: :select,
+            options: []
+          }
+        ]
+      },
+      'disabilityId' => {
+        attribute: :disability,
+        label: 'Disability',
+        fields: [
+          {
+            id: 'disabilityId',
+            type: :select,
+            options: []
+          }
+        ]
+      },
+      'veteranStatusId' => {
+        attribute: :veteran_status,
+        label: 'Veteran Status',
+        fields: [
+          {
+            id: 'veteranStatusId',
+            type: :select,
+            options: []
+          }
+        ]
+      }
+    }
+
+    TYPES = {
+      'checkbox' => :boolean,
+      'long' => :textarea,
+      'short' => :input,
+      'yes_no' => :boolean
+    }
+  end
+end
diff --git a/app/services/importer/get_greenhouse_fields.rb b/app/services/importer/get_greenhouse_fields.rb
index 73f896f4..eb40ac33 100644
--- a/app/services/importer/get_greenhouse_fields.rb
+++ b/app/services/importer/get_greenhouse_fields.rb
@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
+# This class first determines whether a job is new_format or old_format based on its posting_url.
+# There is a limited amount of format-specific logic in terms of building the locators for certain fields.
+
 module Importer
   # company_id is the ATS identifier for the company
   # Needs the company_id to fetch the education options
   class GetGreenhouseFields < GetApiFields
     def initialize(job, data)
       @company_id = job.company.ats_identifier
+      @new_greenhouse_format = job.posting_url.include?('job-boards')
 
       options = {
         data_source: :api,
         sections: %i[core demographic compliance],
-        standard_fields: STANDARD_FIELDS,
+        standard_fields:,
         types: TYPES
       }
 
@@ -42,7 +46,9 @@ def compliance_section_title = 'EEOC compliance questions'
 
     def compliance_section_description = @data.dig('compliance', 0, 'description')
 
-    def convert_to_numerical_id(value) = value.is_a?(String) && value =~ /question_(\d+)/ ? ::Regexp.last_match(1) : value.to_s
+    def convert_to_numerical_id(value)
+      !@new_greenhouse_format && value =~ /question_(\d+)/ ? ::Regexp.last_match(1) : value
+    end
 
     def core_questions
       questions = @data['questions']
@@ -60,7 +66,7 @@ def education_question_present? = @data['education'].present?
 
     def education_questions = EDUCATION_FIELDS.map { |type| build_education_question(type) }
 
-    def field_id = convert_to_numerical_id(@field['name'] || @field['id'])
+    def field_id = @section == :demographic ? @field['id'].to_s : convert_to_numerical_id(@field['name'])
 
     def field_max_length = (255 if field_type == 'input_text')
 
@@ -82,7 +88,11 @@ def location_questions
       end
     end
 
-    def option_id(option) = option['value'] || option['id']
+    def option_id(option)
+      return option['value'] unless @section == :demographic
+
+      @new_greenhouse_format ? option_label(option) : option['id']
+    end
 
     def option_label(option) = option['label']
 
@@ -99,201 +109,203 @@ def question_id(question) = question.dig('fields', 0, 'name') || question[:attri
     def question_label = @question['label']
 
     def question_required? = @question['required']
-  end
-end
 
-EDUCATION_FIELDS = [
-  'school',
-  'degree',
-  'discipline',
-  'start_date',
-  'end_date'
-]
-
-STANDARD_FIELDS = {
-  'first_name' => {
-    attribute: :first_name,
-    fields: [
-      {
-        id: 'first_name',
-        selector: nil,
-        type: :input,
-        max_length: 255,
-        options: []
-      }
-    ]
-  },
-  'last_name' => {
-    attribute: :last_name,
-    fields: [
-      {
-        id: 'last_name',
-        selector: nil,
-        type: :input,
-        max_length: 255,
-        options: []
-      }
-    ]
-  },
-  'email' => {
-    attribute: :email,
-    fields: [
-      {
-        id: 'email',
-        selector: nil,
-        type: :input,
-        max_length: 255,
-        options: []
-      }
-    ]
-  },
-  'phone' => {
-    attribute: :phone_number,
-    fields: [
-      {
-        id: 'phone',
-        selector: nil,
-        type: :input,
-        max_length: 255,
-        options: []
-      }
-    ]
-  },
-  'location' => {
-    attribute: :city_applicant,
-    label: 'Location (City)',
-    fields: [
-      {
-        id: 'auto_complete_input',
-        selector: 'input[name="job_application[location]"]',
-        type: :location,
-        max_length: 255,
-        options: []
-      }
-    ]
-  },
-  'resume' => {
-    attribute: :resume,
-    fields: [
-      {
-        id: nil,
-        selector: 'button[aria-describedby="resume-allowable-file-types"]',
-        type: :upload,
-        max_length: 255,
-        options: []
-      },
-      {
-        id: 'resume_text',
-        selector: nil,
-        type: :input,
-        options: []
-      }
+    EDUCATION_FIELDS = [
+      'school',
+      'degree',
+      'discipline',
+      'start_date',
+      'end_date'
     ]
-  },
-  'cover_letter' => {
-    attribute: :cover_letter,
-    fields: [
-      {
-        id: nil,
-        selector: 'button[aria-describedby="cover_letter-allowable-file-types"]',
-        type: :upload,
-        max_length: 255,
-        options: []
-      },
-      {
-        id: 'cover_letter_text',
-        selector: nil,
-        type: :input,
-        options: []
-      }
-    ]
-  },
-  'school' => {
-    attribute: :school_applicant,
-    label: 'School',
-    description: nil,
-    fields: [
-      {
-        id: 'education_school_name_0',
-        selector: 'input[name="job_application[educations][][school_name_id]"]',
-        type: :education_select
-      }
-    ]
-  },
-  'degree' => {
-    attribute: :degree_applicant,
-    label: 'Degree',
-    description: nil,
-    fields: [
-      {
-        id: 'education_degree_0',
-        selector: 'select[name="job_application[educations][][degree_id]"]',
-        type: :education_select,
-        options: []
-      }
-    ]
-  },
-  'discipline' => {
-    attribute: :discipline_applicant,
-    label: 'Discipline',
-    description: nil,
-    fields: [
-      {
-        id: 'education_discipline_0',
-        selector: 'select[name="job_application[educations][][discipline_id]"]',
-        type: :education_select,
-        options: []
-      }
-    ]
-  },
-  'start_date' => {
-    attribute: :education_start_date_applicant,
-    label: 'Start Date',
-    description: nil,
-    fields: [
-      {
-        id: nil,
-        selector: 'input[name="job_application[educations][][start_date][month]"]',
-        type: :education_input,
-        max_length: 2,
-        options: []
-      },
-      {
-        id: nil,
-        selector: 'input[name="job_application[educations][][start_date][year]"]',
-        type: :education_input,
-        max_length: 4,
-        options: []
-      }
-    ]
-  },
-  'end_date' => {
-    attribute: :education_end_date_applicant,
-    label: 'End Date',
-    description: nil,
-    fields: [
-      {
-        id: nil,
-        selector: 'input[name="job_application[educations][][end_date][month]"]',
-        type: :education_input,
-        max_length: 2,
-        options: []
-      },
+
+    def standard_fields
       {
-        id: nil,
-        selector: 'input[name="job_application[educations][][end_date][year]"]',
-        type: :education_input,
-        max_length: 4,
-        options: []
+        'first_name' => {
+          attribute: :first_name,
+          fields: [
+            {
+              id: 'first_name',
+              selector: nil,
+              type: :input,
+              max_length: 255,
+              options: []
+            }
+          ]
+        },
+        'last_name' => {
+          attribute: :last_name,
+          fields: [
+            {
+              id: 'last_name',
+              selector: nil,
+              type: :input,
+              max_length: 255,
+              options: []
+            }
+          ]
+        },
+        'email' => {
+          attribute: :email,
+          fields: [
+            {
+              id: 'email',
+              selector: nil,
+              type: :input,
+              max_length: 255,
+              options: []
+            }
+          ]
+        },
+        'phone' => {
+          attribute: :phone_number,
+          fields: [
+            {
+              id: 'phone',
+              selector: nil,
+              type: :input,
+              max_length: 255,
+              options: []
+            }
+          ]
+        },
+        'location' => {
+          attribute: :city_applicant,
+          label: 'Location (City)',
+          fields: [
+            {
+              id: 'auto_complete_input',
+              selector: 'input[name="job_application[location]"]',
+              type: :location,
+              max_length: 255,
+              options: []
+            }
+          ]
+        },
+        'resume' => {
+          attribute: :resume,
+          fields: [
+            {
+              id: ('resume' if @new_greenhouse_format),
+              selector: ('button[aria-describedby="resume-allowable-file-types"]' unless @new_greenhouse_format),
+              type: :upload,
+              max_length: 255,
+              options: []
+            },
+            {
+              id: 'resume_text',
+              selector: nil,
+              type: :input,
+              options: []
+            }
+          ]
+        },
+        'cover_letter' => {
+          attribute: :cover_letter,
+          fields: [
+            {
+              id: ('cover_letter' if @new_greenhouse_format),
+              selector: ('button[aria-describedby="cover_letter-allowable-file-types"]' unless @new_greenhouse_format),
+              type: :upload,
+              max_length: 255,
+              options: []
+            },
+            {
+              id: 'cover_letter_text',
+              selector: nil,
+              type: :input,
+              options: []
+            }
+          ]
+        },
+        'school' => {
+          attribute: :school_applicant,
+          label: 'School',
+          description: nil,
+          fields: [
+            {
+              id: 'education_school_name_0',
+              selector: 'input[name="job_application[educations][][school_name_id]"]',
+              type: :education_select
+            }
+          ]
+        },
+        'degree' => {
+          attribute: :degree_applicant,
+          label: 'Degree',
+          description: nil,
+          fields: [
+            {
+              id: 'education_degree_0',
+              selector: 'select[name="job_application[educations][][degree_id]"]',
+              type: :education_select,
+              options: []
+            }
+          ]
+        },
+        'discipline' => {
+          attribute: :discipline_applicant,
+          label: 'Discipline',
+          description: nil,
+          fields: [
+            {
+              id: 'education_discipline_0',
+              selector: 'select[name="job_application[educations][][discipline_id]"]',
+              type: :education_select,
+              options: []
+            }
+          ]
+        },
+        'start_date' => {
+          attribute: :education_start_date_applicant,
+          label: 'Start Date',
+          description: nil,
+          fields: [
+            {
+              id: nil,
+              selector: 'input[name="job_application[educations][][start_date][month]"]',
+              type: :education_input,
+              max_length: 2,
+              options: []
+            },
+            {
+              id: nil,
+              selector: 'input[name="job_application[educations][][start_date][year]"]',
+              type: :education_input,
+              max_length: 4,
+              options: []
+            }
+          ]
+        },
+        'end_date' => {
+          attribute: :education_end_date_applicant,
+          label: 'End Date',
+          description: nil,
+          fields: [
+            {
+              id: nil,
+              selector: 'input[name="job_application[educations][][end_date][month]"]',
+              type: :education_input,
+              max_length: 2,
+              options: []
+            },
+            {
+              id: nil,
+              selector: 'input[name="job_application[educations][][end_date][year]"]',
+              type: :education_input,
+              max_length: 4,
+              options: []
+            }
+          ]
+        }
       }
-    ]
-  }
-}
-
-TYPES = {
-  'input_file' => :upload,
-  'input_text' => :input,
-  'multi_value_multi_select' => :multi_select,
-  'multi_value_single_select' => :select,
-  'textarea' => :textarea
-}
+    end
+
+    TYPES = {
+      'input_file' => :upload,
+      'input_text' => :input,
+      'multi_value_multi_select' => :multi_select,
+      'multi_value_single_select' => :select,
+      'textarea' => :textarea
+    }
+  end
+end
diff --git a/app/tasks/company_creator.rb b/app/tasks/company_creator.rb
index 800a754e..28ceb56b 100644
--- a/app/tasks/company_creator.rb
+++ b/app/tasks/company_creator.rb
@@ -12,9 +12,9 @@ def call
     return unless processable
 
     process
-    # rescue StandardError => e
-    #   Rails.logger.error "Error creating company: #{e.message}"
-    #   nil
+  rescue StandardError => e
+    Rails.logger.error "Error creating company: #{e.message}"
+    nil
   end
 
   private
diff --git a/app/tasks/job_creator.rb b/app/tasks/job_creator.rb
index f75b55da..42aba7b9 100644
--- a/app/tasks/job_creator.rb
+++ b/app/tasks/job_creator.rb
@@ -12,9 +12,9 @@ def call
     return unless processable
 
     process
-  rescue StandardError => e
-    Rails.logger.error "Error creating job: #{e.message}"
-    nil
+    # rescue StandardError => e
+    #   Rails.logger.error "Error creating job: #{e.message}"
+    #   nil
   end
 
   private
diff --git a/spec/fixtures/cassettes/create_company_ashbyhq.yml b/spec/fixtures/cassettes/create_company_ashbyhq.yml
index 1f906154..c6817e63 100644
--- a/spec/fixtures/cassettes/create_company_ashbyhq.yml
+++ b/spec/fixtures/cassettes/create_company_ashbyhq.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:05 GMT
+      - Tue, 30 Jul 2024 16:27:47 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -27,7 +27,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J1CYKZTCH925YJ95G0JYKYGK
+      - 01J427G8EPYCANSHJT9KR5SPYN
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -43,14 +43,14 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 89a5d46b3b6923dd-LHR
+      - 8ab6b7d56c653694-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"jobs":[{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">From time to time, we'll expect you to produce content or present to our community. We're big believers in engaging with our community as much as possible.</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - From time to time, we'll expect you to produce content or present to our community. We're big believers in engaging with our community as much as possible.\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
-  recorded_at: Thu, 27 Jun 2024 13:37:05 GMT
+        {"jobs":[{"id":"309706bc-1081-48b6-89dc-f769bbe17e6d","title":"Analytics Engineering Advocate","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-07-15T16:45:14.721+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d","applyUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d/application","descriptionHtml":"<h2>About Lightdash</h2><p style=\"min-height:1.5em\">Lightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.</p><p style=\"min-height:1.5em\">We’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.</p><p style=\"min-height:1.5em\">We’re helping data teams build data-driven companies so they can make better decisions, faster.</p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><h2>About the role</h2><p style=\"min-height:1.5em\">At Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.</p><p style=\"min-height:1.5em\">Our users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.</p><p style=\"min-height:1.5em\"></p><h2><strong>Areas of Responsibility:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>Obsess over the success of our users:</strong> Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.</p></li><li><p style=\"min-height:1.5em\"><strong>Lightdash champion:</strong> You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash <em><strong>at</strong></em> Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.</p></li><li><p style=\"min-height:1.5em\"><strong>Teach and share:</strong> Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.</p></li><li><p style=\"min-height:1.5em\"><strong>Community strategy:</strong> Building and executing strategies to grow and engage the analyst community around Lightdash.</p></li></ul><h2><strong>Requirements:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Experience with business intelligence and analytics engineering</p></li><li><p style=\"min-height:1.5em\">Strong verbal and written communication skills</p></li><li><p style=\"min-height:1.5em\">Comfortable with dbt, SQL, git, data visualization, and the command line</p></li></ul><h2><strong>KPIs owned by the role (WIP):</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Community size and engagement</p></li><li><p style=\"min-height:1.5em\">Customer support response times and NPS</p></li><li><p style=\"min-height:1.5em\">Content published and hits</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"ABOUT LIGHTDASH\n\nLightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.\n\nWe’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.\n\nWe’re helping data teams build data-driven companies so they can make better decisions, faster.\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nABOUT THE ROLE\n\nAt Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.\n\nOur users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.\n\n\nAREAS OF RESPONSIBILITY:\n\n - Obsess over the success of our users: Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.\n\n - Lightdash champion: You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash at Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.\n\n - Teach and share: Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.\n\n - Community strategy: Building and executing strategies to grow and engage the analyst community around Lightdash.\n\n\nREQUIREMENTS:\n\n - Experience with business intelligence and analytics engineering\n\n - Strong verbal and written communication skills\n\n - Comfortable with dbt, SQL, git, data visualization, and the command line\n\n\nKPIS OWNED BY THE ROLE (WIP):\n\n - Community size and engagement\n\n - Customer support response times and NPS\n\n - Content published and hits\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £95K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £95K","compensationTiers":[{"id":"7cc7b9bb-3f87-4a9c-8e43-604566dbbb54","tierSummary":"£60K – £95K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"13d62bbc-1c15-4ff9-9480-feef72e9847a","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"id":"5c26b271-dd8b-4749-acd3-be1a3b94e870","summary":"£60K – £95K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}],"summaryComponents":[{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}},{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
+  recorded_at: Tue, 30 Jul 2024 16:27:47 GMT
 - request:
     method: post
     uri: https://jobs.ashbyhq.com/api/non-user-graphql?op=ApiOrganizationFromHostedJobsPageName
@@ -77,7 +77,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:06 GMT
+      - Tue, 30 Jul 2024 16:27:47 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -85,7 +85,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J1CYM0076V7V8HF6YYVVKEYM
+      - 01J427G8QFMH947XHX5FRMA6XP
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -103,16 +103,16 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 89a5d46c7f0876a7-LHR
+      - 8ab6b7d77bef652a-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
-      string: '{"data":{"organization":{"name":"Lightdash","publicWebsite":"https://www.lightdash.com/","customJobsPageUrl":null,"hostedJobsPageSlug":"Lightdash","allowJobPostIndexing":true,"appConfirmationTrackingPixelHtml":null,"recruitingPrivacyPolicyUrl":null,"activeFeatureFlags":["AnonymousCandidateExperience","JobPostingApplicationDeadlines","SchedulingNewAvailabileTimesCalculation","UnsubscribeLinks","VirusScanFiles","VirusScanShowResults"],"timezone":"Europe/London","__typename":"Organization","theme":{"colors":{"version":"1","colorPrimary600":"#7262FF","colorPrimary900":"#7262FF"},"showJobFilters":false,"showTeams":false,"showAutofillApplicationsBox":true,"applicationSubmittedSuccessMessage":null,"__typename":"Theme","logoWordmarkImageUrl":"https://app.ashbyhq.com/api/images/org-theme-wordmark/118a5d75-b907-4616-ade7-b67eaa6b5c16/314e7c4e-d0d9-494f-b7cd-7d008d80f41e.png","logoSquareImageUrl":"https://app.ashbyhq.com/api/images/org-theme-logo/118a5d75-b907-4616-ade7-b67eaa6b5c16/0e2997f7-6255-4c9e-9ea4-0199b51c80ef.png","jobBoardTopDescriptionHtml":null,"jobBoardBottomDescriptionHtml":null}}}}'
-  recorded_at: Thu, 27 Jun 2024 13:37:06 GMT
+      string: '{"data":{"organization":{"name":"Lightdash","publicWebsite":"https://www.lightdash.com/","customJobsPageUrl":null,"hostedJobsPageSlug":"Lightdash","allowJobPostIndexing":true,"appConfirmationTrackingPixelHtml":null,"recruitingPrivacyPolicyUrl":null,"activeFeatureFlags":["AnonymousCandidateExperience","JobPostingAlwaysReturnFormRenders","JobPostingApplicationDeadlines","SchedulingNewDirectBookingReschedule","SourcingFormAutoFill","UnsubscribeLinks","VirusScanFiles","VirusScanShowResults"],"timezone":"Europe/London","__typename":"Organization","theme":{"colors":{"version":"1","colorPrimary600":"#7262FF","colorPrimary900":"#7262FF"},"showJobFilters":false,"showTeams":false,"showAutofillApplicationsBox":true,"applicationSubmittedSuccessMessage":null,"__typename":"Theme","logoWordmarkImageUrl":"https://app.ashbyhq.com/api/images/org-theme-wordmark/118a5d75-b907-4616-ade7-b67eaa6b5c16/314e7c4e-d0d9-494f-b7cd-7d008d80f41e.png","logoSquareImageUrl":"https://app.ashbyhq.com/api/images/org-theme-logo/118a5d75-b907-4616-ade7-b67eaa6b5c16/0e2997f7-6255-4c9e-9ea4-0199b51c80ef.png","jobBoardTopDescriptionHtml":null,"jobBoardBottomDescriptionHtml":null}}}}'
+  recorded_at: Tue, 30 Jul 2024 16:27:47 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.lightdash.com/"]}],"limit":1}'
@@ -135,9 +135,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Thu, 27 Jun 2024 13:37:07 GMT
+      - Tue, 30 Jul 2024 16:27:48 GMT
       Etag:
-      - W/"1719495427124"
+      - W/"1722356868526"
       Server:
       - openresty
       X-Cb-Engine:
@@ -153,14 +153,14 @@ http_interactions:
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '426'
+      - '14'
       Content-Length:
-      - '486'
+      - '498'
       Connection:
       - keep-alive
     body:
       encoding: UTF-8
-      string: '{"count":1,"entities":[{"uuid":"301bce04-1610-4369-a9db-29de9623e65f","properties":{"name":"Lightdash","identifier":{"permalink":"hubble-e65f","image_id":"citkfzfr7esouu3essw6","uuid":"301bce04-1610-4369-a9db-29de9623e65f","entity_def_id":"organization","value":"Lightdash"},"linkedin":{"value":"https://www.linkedin.com/company/lightdash"},"short_description":"Lightdash
-        turns a dbt project into a full-stack BI platform.","rank_org":83659,"website_url":"https://www.lightdash.com"}}]}'
-  recorded_at: Thu, 27 Jun 2024 13:37:07 GMT
+      string: '{"count":1,"entities":[{"uuid":"301bce04-1610-4369-a9db-29de9623e65f","properties":{"name":"Lightdash","identifier":{"permalink":"hubble-e65f","image_id":"1c3c7ecd819e45879f8987babbbf2fea","uuid":"301bce04-1610-4369-a9db-29de9623e65f","entity_def_id":"organization","value":"Lightdash"},"linkedin":{"value":"https://www.linkedin.com/company/lightdash"},"short_description":"Lightdash
+        turns a dbt project into a full-stack BI platform.","rank_org":80511,"website_url":"https://www.lightdash.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:27:48 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_bamboohr.yml b/spec/fixtures/cassettes/create_company_bamboohr.yml
index cd0b87d3..2c18af19 100644
--- a/spec/fixtures/cassettes/create_company_bamboohr.yml
+++ b/spec/fixtures/cassettes/create_company_bamboohr.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:08 GMT
+      - Tue, 30 Jul 2024 16:27:49 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -27,8 +27,9 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - PHPSESSID=jCI0oesFh3xz5Ng5pNezqBOxPHI4W6Zd; path=/; secure; HttpOnly; SameSite=None
-      - _cfuvid=6bC5zOlReUtJOG.ixoFCYEtR5hA0_hXE8wXg_kIyKt8-1719495428191-0.0.1.1-604800000;
+      - PHPSESSID=y-%2Cnr%2Csp9LZ59-o2GuzEmf7TSL63bHDD; path=/; secure; HttpOnly;
+        SameSite=None
+      - _cfuvid=yhgNb23pY7t02elm2r_wgUBhkYXTQ34v656dw43FU9E-1722356869371-0.0.1.1-604800000;
         path=/; domain=.bamboohr.com; HttpOnly; Secure; SameSite=None
       Expires:
       - Thu, 19 Nov 1981 08:52:00 GMT
@@ -93,11 +94,11 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 89a5d4774b2293fb-LHR
+      - 8ab6b7de6ad3955c-LHR
     body:
       encoding: ASCII-8BIT
-      string: '{"meta":[],"result":{"name":"Avidbots","id":"72799","logoUrl":"https:\/\/images3.bamboohr.com\/72799\/logos\/cropped.jpg?v=32","careerShareUrl":"https:\/\/avidbots.bamboohr.com\/careers","shareImageUrl":"https:\/\/avidbots.bamboohr.com\/jobs\/share_image\/32","inTrial":false,"appSessId":"10849400f1c97860cedbba354dd51727d353865a"}}'
-  recorded_at: Thu, 27 Jun 2024 13:37:08 GMT
+      string: '{"meta":[],"result":{"name":"Avidbots","id":"72799","logoUrl":"https:\/\/images3.bamboohr.com\/72799\/logos\/cropped.jpg?v=32","careerShareUrl":"https:\/\/avidbots.bamboohr.com\/careers","shareImageUrl":"https:\/\/avidbots.bamboohr.com\/jobs\/share_image\/32","inTrial":false,"appSessId":"8543dbd83baba96408b91a8fa6ed28026e4d7394"}}'
+  recorded_at: Tue, 30 Jul 2024 16:27:49 GMT
 - request:
     method: get
     uri: https://avidbots.bamboohr.com/careers/list
@@ -117,7 +118,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:08 GMT
+      - Tue, 30 Jul 2024 16:27:49 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -125,8 +126,8 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - PHPSESSID=YdbgN%2CMFA-3M7EQGP8LZyOkQ3jvnldhd; path=/; secure; HttpOnly; SameSite=None
-      - _cfuvid=cPuUdo.8v5.YseY_Y7jB5205A75sZPT0H1NR4JqJDzw-1719495428705-0.0.1.1-604800000;
+      - PHPSESSID=iXJSP1hLe75xOALKFd0DPnTOU7Zp0Nry; path=/; secure; HttpOnly; SameSite=None
+      - _cfuvid=tgVLkcm8d7fy3VaCaHucLbRcZSiprYca2IXxSuSNO0w-1722356869889-0.0.1.1-604800000;
         path=/; domain=.bamboohr.com; HttpOnly; Secure; SameSite=None
       Expires:
       - Thu, 19 Nov 1981 08:52:00 GMT
@@ -191,23 +192,40 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 89a5d47a6b3d7717-LHR
+      - 8ab6b7e1cac576ba-LHR
     body:
       encoding: ASCII-8BIT
-      string: '{"meta":{"totalCount":8},"result":[{"id":"693","jobOpeningName":"Technical
+      string: '{"meta":{"totalCount":17},"result":[{"id":"693","jobOpeningName":"Technical
         Support Specialist English","departmentId":"19493","departmentLabel":"Technical
         Support","employmentStatusLabel":"Full-Time","location":{"city":"Cali","state":"Colombia"},"atsLocation":{"country":null,"state":null,"province":null,"city":null},"isRemote":null,"locationType":"2"},{"id":"783","jobOpeningName":"IT
         Specialist","departmentId":"18495","departmentLabel":"IT","employmentStatusLabel":"Full-Time","location":{"city":"Hyderabad
-        ","state":"Telangana"},"atsLocation":{"country":null,"state":null,"province":null,"city":null},"isRemote":null,"locationType":"2"},{"id":"790","jobOpeningName":"Contracts
-        Management Specialist","departmentId":"18609","departmentLabel":"Finance","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Waterloo"},"isRemote":null,"locationType":"1"},{"id":"792","jobOpeningName":"Director
-        of Financial Planning & Analysis","departmentId":"18609","departmentLabel":"Finance","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Waterloo"},"isRemote":null,"locationType":"1"},{"id":"793","jobOpeningName":"Director
-        of Financial Planning & Analysis","departmentId":"18609","departmentLabel":"Finance","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
-        States","state":"Illinois","province":null,"city":"Chicago"},"isRemote":null,"locationType":"1"},{"id":"795","jobOpeningName":"Traveling
+        ","state":"Telangana"},"atsLocation":{"country":null,"state":null,"province":null,"city":null},"isRemote":null,"locationType":"2"},{"id":"792","jobOpeningName":"Director
+        of Financial Planning & Analysis","departmentId":"18609","departmentLabel":"Finance","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Waterloo"},"isRemote":null,"locationType":"1"},{"id":"795","jobOpeningName":"Traveling
         Service Technician (fixed term contract until June 2025)","departmentId":"19494","departmentLabel":"Field
         Service","employmentStatusLabel":"Contract - Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Brampton"},"isRemote":null,"locationType":"1"},{"id":"796","jobOpeningName":"Traveling
         Service Technician (fixed term contract until June 2025)","departmentId":"19494","departmentLabel":"Field
         Service","employmentStatusLabel":"Contract - Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Mississauga"},"isRemote":null,"locationType":"1"},{"id":"797","jobOpeningName":"Traveling
         Service Technician (fixed term contract until June 2025)","departmentId":"19494","departmentLabel":"Field
-        Service","employmentStatusLabel":"Contract - Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Scarborough"},"isRemote":null,"locationType":"1"}]}'
-  recorded_at: Thu, 27 Jun 2024 13:37:08 GMT
+        Service","employmentStatusLabel":"Contract - Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Scarborough"},"isRemote":null,"locationType":"1"},{"id":"798","jobOpeningName":"Traveling
+        Service Technician ","departmentId":"19494","departmentLabel":"Field Service","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Mississauga"},"isRemote":null,"locationType":"1"},{"id":"799","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"Canada","state":"Ontario","province":null,"city":"Toronto"},"isRemote":null,"locationType":"1"},{"id":"800","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
+        States","state":"Illinois","province":null,"city":"Chicago"},"isRemote":null,"locationType":"1"},{"id":"801","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
+        States","state":"Massachusetts","province":null,"city":"Boston"},"isRemote":null,"locationType":"1"},{"id":"802","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
+        States","state":"Texas","province":null,"city":"Dallas"},"isRemote":null,"locationType":"1"},{"id":"803","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
+        States","state":"North Carolina","province":null,"city":"Charlotte"},"isRemote":null,"locationType":"1"},{"id":"804","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
+        States","state":"Michigan","province":null,"city":"Detroit"},"isRemote":null,"locationType":"1"},{"id":"805","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
+        States","state":"Minnesota","province":null,"city":"Minneapolis"},"isRemote":null,"locationType":"1"},{"id":"806","jobOpeningName":"Strategic
+        Account Executive","departmentId":"18446","departmentLabel":"Sales","employmentStatusLabel":"Full-Time","location":{"city":null,"state":null},"atsLocation":{"country":"United
+        States","state":"Utah","province":null,"city":"Salt Lake City"},"isRemote":null,"locationType":"1"},{"id":"807","jobOpeningName":"Customer
+        Care Associate, CPG Coordinator","departmentId":"19492","departmentLabel":"Support
+        Operations","employmentStatusLabel":"Full-Time","location":{"city":"Cali","state":"Colombia"},"atsLocation":{"country":null,"state":null,"province":null,"city":null},"isRemote":null,"locationType":"2"},{"id":"808","jobOpeningName":"Senior
+        Manager, Software Development, Web & Mobile","departmentId":"18433","departmentLabel":"Engineering
+        ","employmentStatusLabel":"Full-Time","location":{"city":"Kitchener","state":"Ontario"},"atsLocation":{"country":null,"state":null,"province":null,"city":null},"isRemote":null,"locationType":"2"}]}'
+  recorded_at: Tue, 30 Jul 2024 16:27:49 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_greenhouse.yml b/spec/fixtures/cassettes/create_company_greenhouse.yml
index 84d7b507..3e95193b 100644
--- a/spec/fixtures/cassettes/create_company_greenhouse.yml
+++ b/spec/fixtures/cassettes/create_company_greenhouse.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:44 GMT
+      - Tue, 30 Jul 2024 16:27:50 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -36,9 +36,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - 9fd4b728e1d9b17f5e673ffc32f19184
+      - cc4b79b3e2a07d13200d334cc6f93f9b
       X-Runtime:
-      - '0.011175'
+      - '0.008139'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -59,7 +59,7 @@ http_interactions:
         you have any questions about the validity of an email you have received, we
         encourage you to contact\u0026nbsp;\u003ca href=\"mailto:recruiting@codepath.org\"
         target=\"_blank\"\u003erecruiting@codepath.org\u003c/a\u003e\u0026nbsp;directly.\u0026nbsp;\u0026nbsp;\u003c/em\u003e\u003c/p\u003e"}'
-  recorded_at: Thu, 25 Jul 2024 13:38:44 GMT
+  recorded_at: Tue, 30 Jul 2024 16:27:50 GMT
 - request:
     method: get
     uri: https://job-boards.greenhouse.io/codepath/
@@ -79,7 +79,7 @@ http_interactions:
       message: Found
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:45 GMT
+      - Tue, 30 Jul 2024 16:27:50 GMT
       Transfer-Encoding:
       - chunked
       Connection:
@@ -120,7 +120,7 @@ http_interactions:
     body:
       encoding: UTF-8
       string: ''
-  recorded_at: Thu, 25 Jul 2024 13:38:45 GMT
+  recorded_at: Tue, 30 Jul 2024 16:27:50 GMT
 - request:
     method: get
     uri: https://boards.greenhouse.io/codepath
@@ -140,7 +140,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:45 GMT
+      - Tue, 30 Jul 2024 16:27:51 GMT
       Content-Type:
       - text/html; charset=utf-8
       Transfer-Encoding:
@@ -154,9 +154,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - 8749d9c400b777746edba936f21607a2
+      - '086228c3aff0de2122a22ab79bf681d4'
       X-Runtime:
-      - '0.012518'
+      - '0.011605'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -167,7 +167,7 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         <!DOCTYPE html>
<html lang="en">
<head prefix="og: http://ogp.me/ns#">
<script>var _rollbarConfig = {"accessToken":"a9e544e2eb674f56b12d47e1d2ed4cd1","captureUncaught":true,"payload":{"environment":"production"},"hostBlockList":["linkedin.com","recruitics.com"],"checkIgnore":function(isUncaught, args, payload) {
  try {
    var isPhantomJS = window.navigator.userAgent.match(/phantomjs/i);
    var isSplash= window.navigator.userAgent.match(/splash version/i);
    var firefox = window.navigator.userAgent.match(/(firefox)\/(\w+)/i); // JSON, must escape slash
    var chrome = window.navigator.userAgent.match(/(chrome)\/(\w+)/i); // JSON, must escape slash

    var browserExtensionOrAutomationFile = function(frame) {
      var regExPatterns = [/^chrome-extension/, /^safari-extension/, /^moz-extension/, /^pptr/];
      return regExPatterns.some(function(regEx) {
        return regEx.test(frame.filename);
      });
    }

    var isBrowserExtensionOrAutomation = payload.body.trace &&
                                         payload.body.trace.frames &&
                                         payload.body.trace.frames.some(browserExtensionOrAutomationFile);

    var isFirefoxLessThan50;
    if (firefox) {
      var majorVersion = Number(firefox[2]);
      isFirefoxLessThan50 = majorVersion < 50
    }

    var isChromeLessThan50;
    if (chrome) {
      var chromeVersion = Number(chrome[2]);
      isChromeLessThan50 = chromeVersion < 50;
    }

    return Boolean(isPhantomJS) ||
           Boolean(isSplash) ||
           Boolean(isFirefoxLessThan50) ||
           Boolean(isChromeLessThan50) ||
           Boolean(isBrowserExtensionOrAutomation);
  } catch (e) {
    return true;
  }
}
,"ignoredMessages":["BetterJsPop","vungle","Script error","awliwidget","ResizeObserver loop completed with undelivered notifications.","jQuery is missing","Attempting to configurable attribute of unconfigurable property.","WeakMap is not defined","Cannot change the configurable attribute of","Cannot call method \"get\" of undefined","\\$ is not defined","Can't find variable: \\$","uncaught exception: \\[object Object\\]","Unexpected token ';'","Failed S3 Direct Upload for field: resume","Failed to open/load the window. Dropbox.choose and Dropbox.save should only be called from within a user-triggered event handler such as a tap or click event.","googletag","solana|ethereum","originalPrompt"]};</script>
<script>!function(r){var e={};function o(n){if(e[n])return e[n].exports;var t=e[n]={i:n,l:!1,exports:{}};return r[n].call(t.exports,t,t.exports,o),t.l=!0,t.exports}o.m=r,o.c=e,o.d=function(r,e,n){o.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},o.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},o.t=function(r,e){if(1&e&&(r=o(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var t in r)o.d(n,t,function(e){return r[e]}.bind(null,t));return n},o.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return o.d(e,"a",e),e},o.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},o.p="",o(o.s=0)}([function(r,e,o){"use strict";var n=o(1),t=o(5);_rollbarConfig=_rollbarConfig||{},_rollbarConfig.rollbarJsUrl=_rollbarConfig.rollbarJsUrl||"https://cdn.rollbar.com/rollbarjs/refs/tags/v2.26.1/rollbar.min.js",_rollbarConfig.async=void 0===_rollbarConfig.async||_rollbarConfig.async;var a=n.setupShim(window,_rollbarConfig),l=t(_rollbarConfig);window.rollbar=n.Rollbar,a.loadFull(window,document,!_rollbarConfig.async,_rollbarConfig,l)},function(r,e,o){"use strict";var n=o(2),t=o(3);function a(r){return function(){try{return r.apply(this,arguments)}catch(r){try{console.error("[Rollbar]: Internal error",r)}catch(r){}}}}var l=0;function i(r,e){this.options=r,this._rollbarOldOnError=null;var o=l++;this.shimId=function(){return o},"undefined"!=typeof window&&window._rollbarShims&&(window._rollbarShims[o]={handler:e,messages:[]})}var s=o(4),d=function(r,e){return new i(r,e)},c=function(r){return new s(d,r)};function u(r){return a((function(){var e=this,o=Array.prototype.slice.call(arguments,0),n={shim:e,method:r,args:o,ts:new Date};window._rollbarShims[this.shimId()].messages.push(n)}))}i.prototype.loadFull=function(r,e,o,n,t){var l=!1,i=e.createElement("script"),s=e.getElementsByTagName("script")[0],d=s.parentNode;i.crossOrigin="",i.src=n.rollbarJsUrl,o||(i.async=!0),i.onload=i.onreadystatechange=a((function(){if(!(l||this.readyState&&"loaded"!==this.readyState&&"complete"!==this.readyState)){i.onload=i.onreadystatechange=null;try{d.removeChild(i)}catch(r){}l=!0,function(){var e;if(void 0===r._rollbarDidLoad){e=new Error("rollbar.js did not load");for(var o,n,a,l,i=0;o=r._rollbarShims[i++];)for(o=o.messages||[];n=o.shift();)for(a=n.args||[],i=0;i<a.length;++i)if("function"==typeof(l=a[i])){l(e);break}}"function"==typeof t&&t(e)}()}})),d.insertBefore(i,s)},i.prototype.wrap=function(r,e,o){try{var n;if(n="function"==typeof e?e:function(){return e||{}},"function"!=typeof r)return r;if(r._isWrap)return r;if(!r._rollbar_wrapped&&(r._rollbar_wrapped=function(){o&&"function"==typeof o&&o.apply(this,arguments);try{return r.apply(this,arguments)}catch(o){var e=o;throw e&&("string"==typeof e&&(e=new String(e)),e._rollbarContext=n()||{},e._rollbarContext._wrappedSource=r.toString(),window._rollbarWrappedError=e),e}},r._rollbar_wrapped._isWrap=!0,r.hasOwnProperty))for(var t in r)r.hasOwnProperty(t)&&(r._rollbar_wrapped[t]=r[t]);return r._rollbar_wrapped}catch(e){return r}};for(var p="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,captureEvent,captureDomContentLoaded,captureLoad".split(","),f=0;f<p.length;++f)i.prototype[p[f]]=u(p[f]);r.exports={setupShim:function(r,e){if(r){var o=e.globalAlias||"Rollbar";if("object"==typeof r[o])return r[o];r._rollbarShims={},r._rollbarWrappedError=null;var l=new c(e);return a((function(){e.captureUncaught&&(l._rollbarOldOnError=r.onerror,n.captureUncaughtExceptions(r,l,!0),e.wrapGlobalEventHandlers&&t(r,l,!0)),e.captureUnhandledRejections&&n.captureUnhandledRejections(r,l,!0);var a=e.autoInstrument;return!1!==e.enabled&&(void 0===a||!0===a||function(r){return!("object"!=typeof r||void 0!==r.page&&!r.page)}(a))&&r.addEventListener&&(r.addEventListener("load",l.captureLoad.bind(l)),r.addEventListener("DOMContentLoaded",l.captureDomContentLoaded.bind(l))),r[o]=l,l}))()}},Rollbar:c}},function(r,e,o){"use strict";function n(r,e,o,n){r._rollbarWrappedError&&(n[4]||(n[4]=r._rollbarWrappedError),n[5]||(n[5]=r._rollbarWrappedError._rollbarContext),r._rollbarWrappedError=null);var t=e.handleUncaughtException.apply(e,n);o&&o.apply(r,n),"anonymous"===t&&(e.anonymousErrorsPending+=1)}r.exports={captureUncaughtExceptions:function(r,e,o){if(r){var t;if("function"==typeof e._rollbarOldOnError)t=e._rollbarOldOnError;else if(r.onerror){for(t=r.onerror;t._rollbarOldOnError;)t=t._rollbarOldOnError;e._rollbarOldOnError=t}e.handleAnonymousErrors();var a=function(){var o=Array.prototype.slice.call(arguments,0);n(r,e,t,o)};o&&(a._rollbarOldOnError=t),r.onerror=a}},captureUnhandledRejections:function(r,e,o){if(r){"function"==typeof r._rollbarURH&&r._rollbarURH.belongsToShim&&r.removeEventListener("unhandledrejection",r._rollbarURH);var n=function(r){var o,n,t;try{o=r.reason}catch(r){o=void 0}try{n=r.promise}catch(r){n="[unhandledrejection] error getting `promise` from event"}try{t=r.detail,!o&&t&&(o=t.reason,n=t.promise)}catch(r){}o||(o="[unhandledrejection] error getting `reason` from event"),e&&e.handleUnhandledRejection&&e.handleUnhandledRejection(o,n)};n.belongsToShim=o,r._rollbarURH=n,r.addEventListener("unhandledrejection",n)}}}},function(r,e,o){"use strict";function n(r,e,o){if(e.hasOwnProperty&&e.hasOwnProperty("addEventListener")){for(var n=e.addEventListener;n._rollbarOldAdd&&n.belongsToShim;)n=n._rollbarOldAdd;var t=function(e,o,t){n.call(this,e,r.wrap(o),t)};t._rollbarOldAdd=n,t.belongsToShim=o,e.addEventListener=t;for(var a=e.removeEventListener;a._rollbarOldRemove&&a.belongsToShim;)a=a._rollbarOldRemove;var l=function(r,e,o){a.call(this,r,e&&e._rollbar_wrapped||e,o)};l._rollbarOldRemove=a,l.belongsToShim=o,e.removeEventListener=l}}r.exports=function(r,e,o){if(r){var t,a,l="EventTarget,Window,Node,ApplicationCache,AudioTrackList,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");for(t=0;t<l.length;++t)r[a=l[t]]&&r[a].prototype&&n(e,r[a].prototype,o)}}},function(r,e,o){"use strict";function n(r,e){this.impl=r(e,this),this.options=e,function(r){for(var e=function(r){return function(){var e=Array.prototype.slice.call(arguments,0);if(this.impl[r])return this.impl[r].apply(this.impl,e)}},o="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,_createItem,wrap,loadFull,shimId,captureEvent,captureDomContentLoaded,captureLoad".split(","),n=0;n<o.length;n++)r[o[n]]=e(o[n])}(n.prototype)}n.prototype._swapAndProcessMessages=function(r,e){var o,n,t;for(this.impl=r(this.options);o=e.shift();)n=o.method,t=o.args,this[n]&&"function"==typeof this[n]&&("captureDomContentLoaded"===n||"captureLoad"===n?this[n].apply(this,[t[0],o.ts]):this[n].apply(this,t));return this},r.exports=n},function(r,e,o){"use strict";r.exports=function(r){return function(e){if(!e&&!window._rollbarInitialized){for(var o,n,t=(r=r||{}).globalAlias||"Rollbar",a=window.rollbar,l=function(r){return new a(r)},i=0;o=window._rollbarShims[i++];)n||(n=o.handler),o.handler._swapAndProcessMessages(l,o.messages);window[t]=n,window._rollbarInitialized=!0}}}}]);</script>
  <title>Jobs at CodePath</title>
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  <meta id="viewport" name="viewport" content ="width=device-width, minimum-scale=1.0" />
  <meta id="rendered-by" content="jben" />
  <link rel="stylesheet" media="all" href="https://boards.cdn.greenhouse.io/assets/application-503576cead2d834a5d82da818670031f8db2f2c51eb2512be35e876ded3907a1.css" />
<link rel="stylesheet" media="all" href="https://boards.cdn.greenhouse.io/assets/responsive-95ad71d0f9cbcb13adb28ed74687b15c00a64bb1c4a6ab47ab9072493777804c.css" />
  
        <link rel="stylesheet" media="screen" href="https://s7-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/custom_css_files/400/224/200/original/simple_greenhouse_job_board_(1).css?1718298473" />



    <meta property="og:title" content="CodePath"></meta>
    <meta property="og:description" content="It has come to our attention that the content in CodePath job postings is being utilized by scammers in an attempt to steal personal information. CodePath will never ask for your social security number, banking, credit card, or other financial information as part of the application process. Additionally, CodePath only accepts job applications via https://boards.greenhouse.io/codepath and initial contact to applicants will always come from no-reply@us.greenhouse-mail.io. If you have any questions about the validity of an email you have received, we encourage you to contact recruiting@codepath.org directly.  "></meta>
    <meta property="og:url" content="https://boards.greenhouse.io/codepath"></meta>
    <meta property="og:type" content="article"></meta>
      <meta property="og:image" content="https://s7-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/logos/400/224/200/original/c281ed94-e7ac-460a-93aa-c5ef819d97de.png?1697156490"></meta>

</head>
<body>
  <div id="wrapper">
    <div id="main" class="accessible">
      
<div id="flash_wrapper">
</div>


<div id="logo"><img alt="CodePath Logo" src="https://s7-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/logos/400/224/200/resized/c281ed94-e7ac-460a-93aa-c5ef819d97de.png?1697156490" width="81" height="75" /></div>

  <h1>CodePath</h1>

  <div id="content">
    <p><em>It has come to our attention that the content in CodePath job postings is being utilized by scammers in an attempt to steal personal information. CodePath will never ask for your social security number, banking, credit card, or other financial information as part of the application process. Additionally, CodePath only accepts job applications via&nbsp;</em><a href="https://boards.greenhouse.io/codepath" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://boards.greenhouse.io/codepath&amp;source=gmail&amp;ust=1706222647322000&amp;usg=AOvVaw3cp7GW91VlHWlwm-Vt6Q6w">https://boards.greenhouse.io/codepath</a>&nbsp;<em>and initial contact to applicants will always come from&nbsp;</em><a href="mailto:no-reply@us.greenhouse-mail.io" target="_blank">no-reply@us.greenhouse-mail.io</a>.<em>&nbsp;If you have any questions about the validity of an email you have received, we encourage you to contact&nbsp;<a href="mailto:recruiting@codepath.org" target="_blank">recruiting@codepath.org</a>&nbsp;directly.&nbsp;&nbsp;</em></p>
  </div>

    <h2 id="board_title">Current Job Openings</h2>

  



<div id="filter-count"></div>

  

<section class="level-0">
  <h3 id="4012729007">Office of the CEO</h3>

  <div class="opening" department_id="4012729007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true">
  <a data-mapped="true" href="/codepath/jobs/4035993007">Chief Learning Officer</a>
  <br/>
  <span class="location">United States</span>
</div>
  

<section class="child level-1">
  <h4 id="4012734007">Business Operations</h4>

  
  

<section class="child level-2">
  <h5 id="4012737007">People</h5>

  <div class="opening" department_id="4012729007,4012734007,4012737007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012734007="true" data-department-4012737007="true">
  <a data-mapped="true" href="/codepath/jobs/4228695007">Head of People</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  
</section>
</section>

<section class="child level-1">
  <h4 id="4012741007">Delivery </h4>

  <div class="opening" department_id="4012729007,4012741007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true">
  <a data-mapped="true" href="/codepath/jobs/4231989007">Senior Director of Learning</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  

<section class="child level-2">
  <h5 id="4012747007">Immersives </h5>

  <div class="opening" department_id="4012729007,4012741007,4012747007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012747007="true">
  <a data-mapped="true" href="/codepath/jobs/4426096007">Associate Instructor - Part Time, Fall Contract</a>
  <br/>
  <span class="location">Arlington, Virginia</span>
</div><div class="opening" department_id="4012729007,4012741007,4012747007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012747007="true">
  <a data-mapped="true" href="/codepath/jobs/4426098007">Lead Instructor - Part Time, Fall Contract</a>
  <br/>
  <span class="location">Arlington, Virginia</span>
</div><div class="opening" department_id="4012729007,4012741007,4012747007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012747007="true">
  <a data-mapped="true" href="/codepath/jobs/4426092007">Tech Fellow - Part-Time, Fall Contract</a>
  <br/>
  <span class="location">Arlington, Virginia</span>
</div>
  
</section>

<section class="child level-2">
  <h5 id="4012742007">Programs</h5>

  <div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4040346007">Lead Cybersecurity Instructor, Fall 2024</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4059099007">Lead Web Development Instructor Adjunct Fall 2024, Miami</a>
  <br/>
  <span class="location">Miami, Florida</span>
</div><div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4038805007">Lead Web Development Instructor, Fall 2024</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4321186007">Technical Interview Prep Instructor, Fall 2024</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  
</section>
</section>

<section class="child level-1">
  <h4 id="4012728007">Marketing</h4>

  <div class="opening" department_id="4012728007,4012729007" office_id="4011420007" data-office-4011420007="true" data-department-4012728007="true" data-department-4012729007="true">
  <a data-mapped="true" href="/codepath/jobs/4425579007">Social Media Manager</a>
  <br/>
  <span class="location">United States</span>
</div>
  
</section>

<section class="child level-1">
  <h4 id="4012730007">Platform</h4>

  <div class="opening" department_id="4012729007,4012730007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012730007="true">
  <a data-mapped="true" href="/codepath/jobs/4426707007">Data Engineer</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012730007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012730007="true">
  <a data-mapped="true" href="/codepath/jobs/4425572007">Lead Product Manager</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012730007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012730007="true">
  <a data-mapped="true" href="/codepath/jobs/4035988007">Staff Software Engineer</a>
  <br/>
  <span class="location">United States</span>
</div>
  
</section>

<section class="child level-1">
  <h4 id="4012731007">Revenue </h4>

  
  

<section class="child level-2">
  <h5 id="4012732007">Philanthropy </h5>

  <div class="opening" department_id="4012729007,4012731007,4012732007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012731007="true" data-department-4012732007="true">
  <a data-mapped="true" href="/codepath/jobs/4384343007">Director of Institutional Giving</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  
</section>
</section>
</section>
  



    </div>
  </div>

      <div id="footer">
    <span>Powered by</span>&nbsp;<a target="_blank" href="http://www.greenhouse.io/">
      <img border="0" alt="Greenhouse Logo" id="gh_logo" src="https://boards.cdn.greenhouse.io/assets/greenhouse-in-app-logo-green-236d994ee39682bb46e214901c264de0df582c97e949e7c854c3531b79f00240.svg" width="100" height="30" />
</a>    <div class="privacy-policy">
      Read our <a href="http://www.greenhouse.io/privacy-policy">Privacy Policy</a>
    </div>
  </div>

      <script src="https://boards.cdn.greenhouse.io/assets/application-fca88733b7aeeaa9c5ec61d2a7c378decfa1d9a2fbf233814adcac2e31b78dab.js"></script>

  <script src="https://boards.cdn.greenhouse.io/assets/index_init-a6a131b5ca4d4c5f93159e6682892d3c22c184dc5c33ad13c69c5fad2dc18a4a.js"></script>  

  </body>
</html>

-  recorded_at: Thu, 25 Jul 2024 13:38:45 GMT
+  recorded_at: Tue, 30 Jul 2024 16:27:51 GMT
 - request:
     method: get
     uri: https://boards-api.greenhouse.io/v1/boards/codepath/jobs
@@ -187,7 +187,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:46 GMT
+      - Tue, 30 Jul 2024 16:27:51 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -204,9 +204,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - 8ef9fe02d9167150e82a87728f6ce745
+      - 79c162fc59c6dabfab760508abc89bd2
       X-Runtime:
-      - '0.074115'
+      - '0.010739'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -246,5 +246,5 @@ http_interactions:
         Fellow - Part-Time, Fall Contract"},{"absolute_url":"https://boards.greenhouse.io/codepath/jobs/4321186007","data_compliance":[{"type":"gdpr","requires_consent":false,"requires_processing_consent":false,"requires_retention_consent":false,"retention_period":null}],"internal_job_id":4212100007,"location":{"name":"Remote,
         United States"},"metadata":null,"id":4321186007,"updated_at":"2024-07-18T18:41:00-04:00","requisition_id":"48","title":"Technical
         Interview Prep Instructor, Fall 2024"}],"meta":{"total":15}}'
-  recorded_at: Thu, 25 Jul 2024 13:38:46 GMT
+  recorded_at: Tue, 30 Jul 2024 16:27:51 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_lever.yml b/spec/fixtures/cassettes/create_company_lever.yml
index f10c2af2..c084c706 100644
--- a/spec/fixtures/cassettes/create_company_lever.yml
+++ b/spec/fixtures/cassettes/create_company_lever.yml
@@ -21,11 +21,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:11 GMT
+      - Tue, 30 Jul 2024 16:27:52 GMT
       Content-Type:
       - text/html; charset=utf-8
       Content-Length:
-      - '476582'
+      - '497174'
       Connection:
       - keep-alive
       Strict-Transport-Security:
@@ -35,14 +35,14 @@ http_interactions:
       X-Xss-Protection:
       - 1; mode=block
       Etag:
-      - W/"745a6-XgSwxi7SVmLYlTrfS+ZthxzXRLg"
+      - W/"79616-uTPrEiNvBBML/V3WjdoJFASVwEM"
       X-Stream-Path:
       - djobs
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        <!DOCTYPE html><html><head prefix="og: http://ogp.me/ns#"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>GoTo Group</title><style>.template-btn-submit.hex-color {background: #00CC33;border-color: #00c230;color: white;}.template-btn-submit.hex-color:visited {color: white;}.template-btn-submit.hex-color:hover {background: #00c230;color: white;}.template-btn-submit.hex-color:active,.template-btn-submit.hex-color:focus {background: #008f24;color: white;}</style><meta name="twitter:card" value="summary"><meta name="twitter:title" content="GoTo Group"><meta name="twitter:description" content="Job openings at GoTo Group"><meta name="twitter:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733905611.png"><meta property="og:title" content="GoTo Group jobs" /><meta property="og:description" content="Job openings at GoTo Group" /><meta property="og:url" content="https://jobs.lever.co/GoToGroup" /><meta property="og:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733917014.png" /><meta property="og:image:height" content="630" /><meta property="og:image:width" content="1200" /><style>@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metaboldlf-webfont-2017.woff") format('woff');font-weight: 600;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormal-webfont-2017.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormalitaliclf-webfont-2017.woff") format('woff');font-weight: 400;font-style: italic;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metabolditaliclf-webfont-2017.woff") format('woff');font-weight: 600;font-style: italic;}@font-face {font-family: 'Meta-Caps';src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.eot");src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Avenir';src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.eot");src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.ttf") format('truetype');font-weight: normal;font-style: normal;}.caps-label,.classic-table th,h4,h6,th,.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.toggle-label,.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before,.cc-btn {font: 14px/1.4em 'Meta-Caps', sans-serif;text-transform: lowercase;letter-spacing: 1px;}.label,body,input,select,textarea,.btn-no-style,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {font: 400 14px/1.4em Meta, sans-serif;text-transform: none;letter-spacing: 0;}p.larger,.large-input,.large-input.dark,.message-banner {font: 400 16px/1.4em Meta, sans-serif;}h1,h2,h3,h5 {font: 600 16px/1.4em Meta, sans-serif;-webkit-font-smoothing: antialiased;}h1,h2,h3,h5 {color: #222326;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;top: 0;bottom: 0;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;right: 0;left: 0;}.hidden {display: none !important;}.fadein {-webkit-animation: lever-fadein 300ms ease-in;-moz-animation: lever-fadein 300ms ease-in;-o-animation: lever-fadein 300ms ease-in;-ms-animation: lever-fadein 300ms ease-in;animation: lever-fadein 300ms ease-in;opacity: 1;-ms-filter: none;filter: none;}.fadeout {-webkit-animation: lever-fadeout 300ms ease-in;-moz-animation: lever-fadeout 300ms ease-in;-o-animation: lever-fadeout 300ms ease-in;-ms-animation: lever-fadeout 300ms ease-in;animation: lever-fadeout 300ms ease-in;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.slidedown {-webkit-animation: lever-slidedown 300ms ease-in;-moz-animation: lever-slidedown 300ms ease-in;-o-animation: lever-slidedown 300ms ease-in;-ms-animation: lever-slidedown 300ms ease-in;animation: lever-slidedown 300ms ease-in;}.slideup {-webkit-animation: lever-slideup 300ms ease-out;-moz-animation: lever-slideup 300ms ease-out;-o-animation: lever-slideup 300ms ease-out;-ms-animation: lever-slideup 300ms ease-out;animation: lever-slideup 300ms ease-out;}.face-off {background-color: #f0f;}.face-off-border {border-color: #f0f !important;}.face-off-label {display: block;position: absolute;top: 24px;font-size: 24px;width: 100%;text-align: center;color: #fff;}.comma-separated:after {content: ", ";}.comma-separated:last-of-type:after {content: "";}.numbers,.dates,.count {font-family: 'Avenir';font-size: 0.857em;}.numbers,.dates {font-size: 0.92em;text-transform: uppercase;}.label {font-size: 12px;color: #969799;}.label.dark {color: #6a7c83;}.caps-label,.classic-table th {font-size: 12px;color: #969799;}.caps-label.dark,.classic-table th.dark {color: #6a7c83;}.vert-space-1 {margin-top: 5px;}.vert-space-2 {margin-top: 10px;}.vert-space-3 {margin-top: 15px;}.vert-space-4 {margin-top: 20px;}.vert-space-5 {margin-top: 25px;}.vert-space-6 {margin-top: 30px;}.vert-space-7 {margin-top: 35px;}.vert-space-8 {margin-top: 40px;}.vert-space-9 {margin-top: 45px;}.vert-space-10 {margin-top: 50px;}.vert-space-11 {margin-top: 55px;}.vert-space-12 {margin-top: 60px;}.full-width {width: 100%;}.left-align {text-align: left;}.right-align {text-align: right;}.centered {text-align: center;}.bulleted-list,.numbered-list {margin-left: 15px;}.bulleted-list li,.numbered-list li {margin-bottom: 8px;}.classic-table.fixed {table-layout: fixed;}.classic-table.no-padding td,.classic-table.no-padding th {padding: initial;}.classic-table.dark td,.classic-table.dark th {border-bottom: 1px solid #536266;}.classic-table.dark th {color: #6a7c83;}.classic-table td,.classic-table th {border-bottom: 1px solid #e3e4e6;padding: 10px 15px;vertical-align: top;}.classic-table td:first-of-type,.classic-table th:first-of-type {padding-left: 0;}.classic-table.no-bottom-border tr:last-child > td,.classic-table.no-bottom-border tr:last-child > th {border-bottom: none;}@-moz-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}* {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}body {background: #f9f9f9;color: #555659;}th {text-align: left;}body,dd,dl,dt,fieldset,form,h1,h2,h3,h4,h5,h6,li,menu,ol,p,td,th,ul,.toggle-label,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;}ul {margin: 0 auto;}table {border-collapse: collapse;border-spacing: 0;}fieldset,img {border: 0;}img.desaturate {-webkit-filter: grayscale(100%);}h1 {font-size: 36px;}h2,h5 {font-size: 24px;}h3 {font-size: 18px;}h5 {font-size: 16px;}h6,th {font-size: 12px;}a,a:visited {color: #579eee;text-decoration: none;}a:hover {color: #555659;cursor: pointer;}a:active {color: #0c92f3;}p>a {text-decoration: underline;color: inherit;}b {font-weight: 600;-webkit-font-smoothing: antialiased;}input,select,textarea {color: #555659;margin: 0;}input,select {height: 30px;}section {padding-bottom: 16px;}button {-webkit-appearance: button;-moz-appearance: button;appearance: button;cursor: pointer;}.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.cc-btn {position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 5px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;color: #555659;background: #fcfcfc;background: -webkit-linear-gradient(top, #fff, #f9f9f9);background: -moz-linear-gradient(top, #fff, #f9f9f9);background: -o-linear-gradient(top, #fff, #f9f9f9);background: -ms-linear-gradient(top, #fff, #f9f9f9);background: linear-gradient(to bottom, #fff, #f9f9f9);-webkit-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-moz-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-o-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-ms-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;}.btn:hover,.submit:hover,.btn-large:hover,.submit-large:hover,.btn-large-secondary:hover,.dark-button:hover,.cc-btn:hover,.btn-invisible:hover,.btn-no-style:hover {color: #1a1b1c;border-color: #969799;}.btn:active,.submit:active,.btn-large:active,.submit-large:active,.btn-large-secondary:active,.dark-button:active,.cc-btn:active {border-color: #555659;background: -webkit-linear-gradient(top, #f9f9f9, #fff);background: -moz-linear-gradient(top, #f9f9f9, #fff);background: -o-linear-gradient(top, #f9f9f9, #fff);background: -ms-linear-gradient(top, #f9f9f9, #fff);background: linear-gradient(to bottom, #f9f9f9, #fff);}.btn:active .icon >path,.submit:active .icon >path,.btn-large:active .icon >path,.submit-large:active .icon >path,.btn-large-secondary:active .icon >path,.dark-button:active .icon >path,.cc-btn:active .icon >path {fill: #555659;}.btn:focus,.submit:focus,.btn-large:focus,.submit-large:focus,.btn-large-secondary:focus,.dark-button:focus,.cc-btn:focus {outline: thin dotted;outline: 3px auto #0c92f3;outline-offset: -2px;}.btn.disabled,.submit.disabled,.btn-large.disabled,.submit-large.disabled,.btn-large-secondary.disabled,.dark-button.disabled,.cc-btn.disabled,.btn:disabled,.submit:disabled,.btn-large:disabled,.submit-large:disabled,.btn-large-secondary:disabled,.dark-button:disabled,.cc-btn:disabled,input.btn:disabled {cursor: default;pointer-events: none;-webkit-box-shadow: none;box-shadow: none;background: #e3e4e6;color: #555659;border-color: #dcdcdc;outline: none;}.btn.disabled.has-tip,.submit.disabled.has-tip,.btn-large.disabled.has-tip,.submit-large.disabled.has-tip,.btn-large-secondary.disabled.has-tip,.dark-button.disabled.has-tip,.cc-btn.disabled.has-tip,.btn:disabled.has-tip,.submit:disabled.has-tip,.btn-large:disabled.has-tip,.submit-large:disabled.has-tip,.btn-large-secondary:disabled.has-tip,.dark-button:disabled.has-tip,.cc-btn:disabled.has-tip,input.btn:disabled.has-tip {pointer-events: auto;}.btn.disabled:hover,.submit.disabled:hover,.btn-large.disabled:hover,.submit-large.disabled:hover,.btn-large-secondary.disabled:hover,.dark-button.disabled:hover,.cc-btn.disabled:hover,.btn:disabled:hover,.submit:disabled:hover,.btn-large:disabled:hover,.submit-large:disabled:hover,.btn-large-secondary:disabled:hover,.dark-button:disabled:hover,.cc-btn:disabled:hover,input.btn:disabled:hover,.btn.disabled:active,.submit.disabled:active,.btn-large.disabled:active,.submit-large.disabled:active,.btn-large-secondary.disabled:active,.dark-button.disabled:active,.cc-btn.disabled:active,.btn:disabled:active,.submit:disabled:active,.btn-large:disabled:active,.submit-large:disabled:active,.btn-large-secondary:disabled:active,.dark-button:disabled:active,.cc-btn:disabled:active,input.btn:disabled:active {color: #555659;background: #e3e4e6;border-color: #dcdcdc;}.btn.dropdown-button,.submit.dropdown-button,.btn-large.dropdown-button,.submit-large.dropdown-button,.btn-large-secondary.dropdown-button,.dark-button.dropdown-button,.cc-btn.dropdown-button {text-align: left;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;padding-right: 19px;}.btn.dropdown-button.full-width,.submit.dropdown-button.full-width,.btn-large.dropdown-button.full-width,.submit-large.dropdown-button.full-width,.btn-large-secondary.dropdown-button.full-width,.dark-button.dropdown-button.full-width,.cc-btn.dropdown-button.full-width {width: 100%;}.btn .icon >path,.submit .icon >path,.btn-large .icon >path,.submit-large .icon >path,.btn-large-secondary .icon >path,.dark-button .icon >path,.cc-btn .icon >path {fill: #555659;}.btn.has-icon,.submit.has-icon,.btn-large.has-icon,.submit-large.has-icon,.btn-large-secondary.has-icon,.dark-button.has-icon,.cc-btn.has-icon {padding-left: 41px;}.btn.has-icon .icon,.submit.has-icon .icon,.btn-large.has-icon .icon,.submit-large.has-icon .icon,.btn-large-secondary.has-icon .icon,.dark-button.has-icon .icon,.cc-btn.has-icon .icon,.btn.has-icon .loading-indicator,.submit.has-icon .loading-indicator,.btn-large.has-icon .loading-indicator,.submit-large.has-icon .loading-indicator,.btn-large-secondary.has-icon .loading-indicator,.dark-button.has-icon .loading-indicator,.cc-btn.has-icon .loading-indicator {position: absolute;left: 15px;top: calc(50% - 8px);}.btn.has-icon .btn-content,.submit.has-icon .btn-content,.btn-large.has-icon .btn-content,.submit-large.has-icon .btn-content,.btn-large-secondary.has-icon .btn-content,.dark-button.has-icon .btn-content,.cc-btn.has-icon .btn-content {position: relative;display: inline-block;}.btn.has-icon .btn-content .icon,.submit.has-icon .btn-content .icon,.btn-large.has-icon .btn-content .icon,.submit-large.has-icon .btn-content .icon,.btn-large-secondary.has-icon .btn-content .icon,.dark-button.has-icon .btn-content .icon,.cc-btn.has-icon .btn-content .icon,.btn.has-icon .btn-content .loading-indicator,.submit.has-icon .btn-content .loading-indicator,.btn-large.has-icon .btn-content .loading-indicator,.submit-large.has-icon .btn-content .loading-indicator,.btn-large-secondary.has-icon .btn-content .loading-indicator,.dark-button.has-icon .btn-content .loading-indicator,.cc-btn.has-icon .btn-content .loading-indicator {left: -26px;}.btn.has-icon.right,.submit.has-icon.right,.btn-large.has-icon.right,.submit-large.has-icon.right,.btn-large-secondary.has-icon.right,.dark-button.has-icon.right,.cc-btn.has-icon.right {padding-left: 15px;padding-right: 41px;}.btn.has-icon.right .icon,.submit.has-icon.right .icon,.btn-large.has-icon.right .icon,.submit-large.has-icon.right .icon,.btn-large-secondary.has-icon.right .icon,.dark-button.has-icon.right .icon,.cc-btn.has-icon.right .icon {right: 15px;left: initial;}.btn small,.submit small,.btn-large small,.submit-large small,.btn-large-secondary small,.dark-button small,.cc-btn small {margin-left: 10px;font-size: 12px;opacity: 0.67;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=67)";filter: alpha(opacity=67);}.btn small.dates,.submit small.dates,.btn-large small.dates,.submit-large small.dates,.btn-large-secondary small.dates,.dark-button small.dates,.cc-btn small.dates {font-size: 11px;}.submit,.submit-large {color: #fff;background: #0c92f3;border: 1px solid #0c92f3;}.submit .icon >path,.submit-large .icon >path {fill: #fff;}.submit:hover,.submit-large:hover {color: #fff;background: #007fd9;border: 1px solid #0c92f3;}.submit:active,.submit-large:active {background: #1a1b1c;border-color: #1a1b1c;}.submit:active .icon >path,.submit-large:active .icon >path {fill: #fff;}.submit:focus,.submit-large:focus {outline-color: #064979;}.btn-large,.btn-large-secondary {padding: 10px 15px;}.submit-large {padding: 10px 15px;}.btn-large-secondary {background: #969799;color: #fff;border: 1px solid #969799;}.btn-large-secondary:hover {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary:active {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary .icon >path {fill: #e3e4e6;}a.btn,a.btn-large {color: #555659;}a.submit,a.submit-large,a.btn-large-secondary {color: #fff;}.dark-button {background: #2c2e2f;border: 1px solid rgba(106,124,131,0.75);color: #e3e4e6;-webkit-transition: background-color 0.15s;-moz-transition: background-color 0.15s;-o-transition: background-color 0.15s;-ms-transition: background-color 0.15s;transition: background-color 0.15s;}.dark-button .icon >path {fill: #dcdcdc;}.dark-button.disabled,.dark-button:disabled {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;pointer-events: none;}.dark-button.disabled .icon > path,.dark-button:disabled .icon > path {fill: rgba(106,124,131,0.5);}.dark-button.disabled.has-tip,.dark-button:disabled.has-tip {pointer-events: auto;}.dark-button.disabled.has-tip:hover,.dark-button:disabled.has-tip:hover {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;}.dark-button.transparent {background-color: transparent;}.dark-button:hover {background: #1a1b1c;border-color: #7d8f95;color: #fcfcfc;}.dark-button:hover .icon > path {fill: #fff;}.dark-button:active {border-color: #dcdcdc;}.icon-only {position: relative;width: 32px;height: 30px;}.icon-only .icon {position: absolute;left: calc(50% - 8px);top: calc(50% - 8px);}.icon-only:hover .icon >path {fill: #555659;}.icon-only:active .icon >path {fill: #2c2e2f;}.icon-only.dark-button:hover .icon >path {fill: #fff;}.btn-invisible,.btn-no-style {color: #555659;padding: 5px 15px;border-color: transparent;-webkit-box-shadow: inset 0 0 0 1px transparent;box-shadow: inset 0 0 0 1px transparent;background: transparent;-webkit-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-moz-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-o-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-ms-transition: background 0.15s, box-shadow 0.15s, color 0.15s;transition: background 0.15s, box-shadow 0.15s, color 0.15s;}.btn-invisible.disabled,.btn-no-style.disabled,.btn-invisible:disabled,.btn-no-style:disabled {cursor: default;}.btn-no-style {padding: 5px 10px 5px 0;vertical-align: baseline;}.btn-no-style:hover {border-color: transparent;color: #555659;}.btn-no-style:focus {border-radius: 0;outline: none;}.btn-no-style.dark {color: #7d8f95;}.btn-no-style.dark:hover {color: #f9f9f9;}.btn-no-style.dark:active {background: transparent;border-color: transparent;color: #fff;}.btn-no-style .css-icon::before {right: 0;}.link {display: inline-block;position: relative;cursor: pointer;-webkit-transition: all 0.15s;-moz-transition: all 0.15s;-o-transition: all 0.15s;-ms-transition: all 0.15s;transition: all 0.15s;}.link.has-icon {padding-left: 20px;}.link.has-icon .icon {position: absolute;left: 0;top: calc(50% - 8px);}.link.has-icon .icon >path {fill: #969799;}.link.has-icon .icon-plus,.link.has-icon .icon-close,.link.has-icon .icon-delete {top: calc(50% - 10px);}.link.has-icon:hover .icon >path {fill: #555659;}.link.has-icon:active .icon >path {fill: #0c92f3;}.link.dark,.popup-content .link {color: #7d8f95;}.link.dark .icon >path,.popup-content .link .icon >path {fill: #7d8f95;}.link.dark:hover,.popup-content .link:hover {color: #dcdcdc;}.link.dark:hover .icon >path,.popup-content .link:hover .icon >path {fill: #dcdcdc;}.link.dark:active,.popup-content .link:active {color: #fff;}.link.secondary {color: #969799;}.link.secondary:hover {color: #555659;}button.icon-btn {border: 0;background: none;padding: 0;}button.icon-btn:active {outline: none;}.icon-btn {display: inline-block;margin-left: 10px;vertical-align: middle;}.icon-btn .icon {display: block;}.icon-btn .icon >path {fill: #969799;}.icon-btn:hover .icon >path {fill: #555659;}.icon-btn.dark .icon >path {fill: #6a7c83;}.icon-btn.dark:hover .icon >path {fill: #f9f9f9;}.link-bar {display: block;margin-top: 16px;white-space: nowrap;}.link-bar.no-margin {margin-top: 0;}.link-bar .submit,.link-bar .submit-large,.link-bar .dark-button {min-width: 120px;}.link-bar a,.link-bar button {vertical-align: baseline;}.link-bar.right,.link-bar.center {text-align: right;}.link-bar.right a,.link-bar.center a,.link-bar.right button,.link-bar.center button {margin-right: 15px;}.link-bar.right .btn,.link-bar.center .btn,.link-bar.right .dark-button,.link-bar.center .dark-button,.link-bar.right .submit,.link-bar.center .submit {margin-right: 10px;}.link-bar.right *:nth-last-child(1),.link-bar.center *:nth-last-child(1) {margin-right: 0;}.link-bar.left {text-align: left;}.link-bar.left a,.link-bar.left button {margin-left: 15px;}.link-bar.left .btn,.link-bar.left .dark-button,.link-bar.left .submit {margin-left: 10px;}.link-bar.left *:first-child {margin-left: 0;}.link-bar.center {text-align: center;}input[type=radio],input[type=checkbox] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 17px;height: 17px;position: relative;border: 1px solid #dcdcdc;margin: 0;background: #fff;cursor: pointer;}input[type=radio].disabled,input[type=checkbox].disabled,input[type=radio]:disabled,input[type=checkbox]:disabled {background: #e3e4e6;}input[type=radio].dark,input[type=checkbox].dark {background: rgba(106,124,131,0.2);border-color: rgba(106,124,131,0.8);}input[type=radio].dark:checked,input[type=checkbox].dark:checked {background: #dcdcdc;}input[type=radio].dark:focus,input[type=checkbox].dark:focus {background: #f9f9f9;}input[type=radio].dark:active,input[type=checkbox].dark:active {background: #fff;}input[type=radio].dark.disabled,input[type=checkbox].dark.disabled,input[type=radio].dark:disabled,input[type=checkbox].dark:disabled {background: rgba(106,124,131,0.5);}input[type=radio] {border-radius: 8.5px;}input[type=radio]:active {background: #dcdcdc;}input[type=radio]:checked::after {position: absolute;content: "";height: 9px;width: 9px;left: calc(50% - 4.5px);top: calc(50% - 4.5px);border-radius: 4.25px;background-color: #0c92f3;}input[type=checkbox] {border-radius: 3px;}input[type=checkbox]:active {background: #dcdcdc;}input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: 3%;height: 40%;width: 69%;border-bottom: 2px solid #0c92f3;border-left: 2px solid #0c92f3;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}input[type=submit] {height: inherit;}input.required-checkbox[type=checkbox]:hover::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);left: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAADe0lEQVRYCe2WW0jTYRTA3V3pZRWEJJJFUQQFRtCFogt7kV7cxVkGmlBPdoHepCh6CCHoJYIIyvlgLYdzUfjQnSjoQXpIYUSZ9aZQQmNzDHVbvzPa+O/bf9sf0Tf/8PF9536+c853zt9Us4RvZGTkuMlkeqOITrrd7m0KriporsqxwgyrDqxGYDUCVnlloVBoK1vC7/fPrPCrK6gPh8P70+n0WM4Bq9XaB8VDg3nPHlpcXAzjzO8C9zIdhoeH95rN5nbUtdHINmUyGZeV29cBtICUejgmC4fuRiKRdzAMQYt4PJ5Z8Ev6MNqMUT/CfnRt0SqxWCw+bFnF+BotAUYLsAtBF/s9IvOaPRSLxSLd3d1/tbx6Zy61C71yUzFatj1Dc5tQ/pjDKT1FKi6bzc6De8WaROaSlg5thnUffDtrh5ZW6WyFuQ7BNLvcuuIHjx2GE3pM0OpZ1/Vo5XDYnTUzwdypVKoB4DyMH1jZcgLLhJcUDmCvZXx8vN6kKiV/DRRHG/k/CW2fSl8KjLEE0XnGs3tCYb/ghUkqc1+JA3mC7MFgsMlut0shSV73aGkGzkkMj8pLisfjoxRvSk+mogNaAWlWRKaLyFzV4tUzRqfAXUkkEs87OzvnVLoKG54FhE0qf62qQAduhG/KiHGRNewADaUVxT06BotQ8NhADAUCAWcRoQxgyAFqoZHQP9TT8T/kKqnJ6XQGVKQeXNUBcm+pra19xM3WqQowPsg6xNKbG62086JmpcoLXNUBWuo1+A7rCP9KJpM9Xq93mko/A72kf+DYLRlAOrIFVMVXQJs+Audbbl/kKIrT4I8ypD7mNcF7G77LeViz/1xYWGimiGMaXOFYpLiA5YDC9WwS+hIeHOjTGhc5Rngv22c5K99motiv4ApgifICpaamH+MNGjh3xPjYxMTEDRUv3Y2bSveMqzT0ePgBuaDiBdZNgTBT9Xd0BOZop80+n++7Di2HInKnMTio0nF8HvxBRk9RlEocoOq322y2LyhwqEootnMU3QMVr8I4MYCxLhWPEz9I1U7tLChJQTQaldv1wZxRFDw1YlxkaMM9yH9T5CU1vVrjQi+JQF6INLi4hRThBpRNM7J3d3R0/MnTq+3yK8bs+ASfRDJK6ryk7qsqV9YBYaQDbnQ4HEGcuEnuXqrC1WBScRGeA0TkrNHZUE3nstP/Ae08V3wBOebTAAAAAElFTkSuQmCC");background-position: 50% 50%;}input.required-checkbox[type=checkbox]:checked {border: none;background: #f26161;}input.required-checkbox[type=checkbox]:checked:hover {background: #d95757;}input.required-checkbox[type=checkbox]:checked:disabled {background: #f8b0b0;cursor: auto;}input[type=checkbox].required-checkbox:checked::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABtklEQVRIDe2UzStEYRSHZwxpwpSNlNQUEQsbSztK7BUmbKzITvkPWMjKjpSywlIpSc1CkWxkQ5IslCQpHwvCeM6k27nnvnfuhKyceu49H79z3vv5xmJFWi6X2wBtjcW0lhQj+onmf4HIp/c3j4hPYxjqIi+nSAGzyqAXWmIc0iD2AbswAbV2FrmCnyn1UuiGJbgDsXlZYDLv+g/vhFkYgxpZjHNgAXIJ6IQFuAVrV9K4b7MmfiPegTOTXye+MblAGCfTzwUOQg+Uw2/ZCYPWvGEslIIR2IRX+I6d0zQNbd5gl4OgGkZhG+QRFbJLirPQ7poVmaNRvoww26IQjxwSJqC5Ak7Dpn/lh8L6I/MMWDbDX4gPTO6RuDlymBXQlDGDJJyCGriWQNkxftLOCI0RN8CDGiBuFvJ7F+cukJ9R22LoQF2gQ/aRQ92Jfw/1RjdjNBJmtMbpI5pzNMrP6DM0svfsGa28jyafUAcU5dZl09O2ojXaR5QGuTttRwQJrfN8CpWwqtQX+ClP4HCo9yn9E/6AQ+ZPIRqHZ+jwV9wROtlN5X9pdSscWcT5bdpRCqTQJqEqUCDxCYHVRpVrffeeAAAAAElFTkSuQmCC");background-position: 50% 50%;}input::placeholder,textarea::placeholder {color: #969799;}input:-ms-input-placeholder,textarea:-ms-input-placeholder {color: #969799;}.classic-input,.large-input {-webkit-transition: border-color 0.15s, background 0.15s;-moz-transition: border-color 0.15s, background 0.15s;-o-transition: border-color 0.15s, background 0.15s;-ms-transition: border-color 0.15s, background 0.15s;transition: border-color 0.15s, background 0.15s;border: 1px solid #e3e4e6;background-color: #fff;padding: 4px 10px;border-radius: 3px;}.classic-input.invalid,.large-input.invalid {border: 1px solid #d94141;}.classic-input.invalid:focus,.large-input.invalid:focus {outline: none;}.classic-input.invalid:hover,.large-input.invalid:hover {border: 1px solid #d94141;}.classic-input:hover,.large-input:hover {background-color: #fff;border-color: rgba(12,146,243,0.5);}.classic-input:active,.large-input:active,.classic-input:focus,.large-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #fff;border-color: #0c92f3;}.classic-input.disabled,.large-input.disabled,.classic-input:disabled,.large-input:disabled {background: #f9f9f9;color: #969799;}.classic-input.disabled:hover,.large-input.disabled:hover,.classic-input:disabled:hover,.large-input:disabled:hover,.classic-input.disabled:active,.large-input.disabled:active,.classic-input:disabled:active,.large-input:disabled:active {border-color: #e3e4e6;}.classic-input::-ms-clear,.large-input::-ms-clear {display: none;}textarea.classic-input {resize: vertical;}.hoverable-input {-webkit-transition: border-color 0.3s, background-color 0.3s;-moz-transition: border-color 0.3s, background-color 0.3s;-o-transition: border-color 0.3s, background-color 0.3s;-ms-transition: border-color 0.3s, background-color 0.3s;transition: border-color 0.3s, background-color 0.3s;border: 1px solid transparent;background-color: transparent;padding: 4px 10px;border-radius: 3px;}.hoverable-input.invalid {border: 1px solid #d94141;outline: none;}.hoverable-input:hover {background-color: #fff;border-color: #e3e4e6;}.hoverable-input:active,.hoverable-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #f9f9f9;border-color: #e3e4e6;}.dark-input,.large-input.dark {height: 30px;color: #f9f9f9;padding: 4px 10px;background: rgba(106,124,131,0.5);border: none;color: #e3e4e6;border-radius: 3px;}.dark-input.invalid,.large-input.dark.invalid {border: 1px solid #d94141;}.dark-input.invalid:focus,.large-input.dark.invalid:focus {outline: none;}.dark-input.invalid:hover,.large-input.dark.invalid:hover {border: 1px solid #d94141;}.dark-input:hover,.large-input.dark:hover {background: #6a7c83;}.dark-input:focus,.large-input.dark:focus {background: #fff;color: #555659;outline: none;}textarea.dark-input {height: auto;}.large-input {height: 40px;}.large-input.dark {height: 40px;}.no-input {background: none;border: none;outline: none;-webkit-box-shadow: none;box-shadow: none;margin: 0;padding: 0;resize: none;}.no-input.dark {color: #f9f9f9;}.options-list {list-style-type: none;}.options-list li {margin-bottom: 8px;}.options-list li.list-padding {margin-bottom: 16px;}.options-list label {display: block;position: relative;cursor: pointer;}.options-list label input[type=checkbox],.options-list label input[type=radio] {position: absolute;}.options-list label input[type=checkbox] ~ span,.options-list label input[type=radio] ~ span,.options-list label input[type=checkbox] ~ p,.options-list label input[type=radio] ~ p {padding-left: 26px;display: block;color: #555659;}.options-list label input[type=checkbox]:checked ~ span,.options-list label input[type=radio]:checked ~ span,.options-list label input[type=checkbox]:checked ~ p,.options-list label input[type=radio]:checked ~ p {color: #555659;}.popup-content .options-list input[type="checkbox"],.sheets-content .options-list input[type="checkbox"],.modal-legacy.dark .options-list input[type="checkbox"],.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {background: rgba(106,124,131,0.5);border-color: rgba(106,124,131,0.8);}.popup-content .options-list input[type="checkbox"] ~ span,.sheets-content .options-list input[type="checkbox"] ~ span,.modal-legacy.dark .options-list input[type="checkbox"] ~ span,.popup-content .options-list input[type="radio"] ~ span,.sheets-content .options-list input[type="radio"] ~ span,.modal-legacy.dark .options-list input[type="radio"] ~ span,.popup-content .options-list input[type="checkbox"] ~ p,.sheets-content .options-list input[type="checkbox"] ~ p,.modal-legacy.dark .options-list input[type="checkbox"] ~ p,.popup-content .options-list input[type="radio"] ~ p,.sheets-content .options-list input[type="radio"] ~ p,.modal-legacy.dark .options-list input[type="radio"] ~ p {color: #a4b0b4;}.popup-content .options-list input[type="checkbox"]:checked,.sheets-content .options-list input[type="checkbox"]:checked,.modal-legacy.dark .options-list input[type="checkbox"]:checked,.popup-content .options-list input[type="radio"]:checked,.sheets-content .options-list input[type="radio"]:checked,.modal-legacy.dark .options-list input[type="radio"]:checked {background: #dcdcdc;}.popup-content .options-list input[type="checkbox"]:checked ~ span,.sheets-content .options-list input[type="checkbox"]:checked ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ span,.popup-content .options-list input[type="radio"]:checked ~ span,.sheets-content .options-list input[type="radio"]:checked ~ span,.modal-legacy.dark .options-list input[type="radio"]:checked ~ span,.popup-content .options-list input[type="checkbox"]:checked ~ p,.sheets-content .options-list input[type="checkbox"]:checked ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ p,.popup-content .options-list input[type="radio"]:checked ~ p,.sheets-content .options-list input[type="radio"]:checked ~ p,.modal-legacy.dark .options-list input[type="radio"]:checked ~ p {color: #f9f9f9;}.popup-content .options-list input[type="checkbox"]:focus,.sheets-content .options-list input[type="checkbox"]:focus,.modal-legacy.dark .options-list input[type="checkbox"]:focus,.popup-content .options-list input[type="radio"]:focus,.sheets-content .options-list input[type="radio"]:focus,.modal-legacy.dark .options-list input[type="radio"]:focus {background: #f9f9f9;}.popup-content .options-list input[type="checkbox"].disabled,.sheets-content .options-list input[type="checkbox"].disabled,.modal-legacy.dark .options-list input[type="checkbox"].disabled,.popup-content .options-list input[type="radio"].disabled,.sheets-content .options-list input[type="radio"].disabled,.modal-legacy.dark .options-list input[type="radio"].disabled,.popup-content .options-list input[type="checkbox"]:disabled,.sheets-content .options-list input[type="checkbox"]:disabled,.modal-legacy.dark .options-list input[type="checkbox"]:disabled,.popup-content .options-list input[type="radio"]:disabled,.sheets-content .options-list input[type="radio"]:disabled,.modal-legacy.dark .options-list input[type="radio"]:disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="checkbox"].disabled ~ span,.sheets-content .options-list input[type="checkbox"].disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ span,.popup-content .options-list input[type="radio"].disabled ~ span,.sheets-content .options-list input[type="radio"].disabled ~ span,.modal-legacy.dark .options-list input[type="radio"].disabled ~ span,.popup-content .options-list input[type="checkbox"]:disabled ~ span,.sheets-content .options-list input[type="checkbox"]:disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ span,.popup-content .options-list input[type="radio"]:disabled ~ span,.sheets-content .options-list input[type="radio"]:disabled ~ span,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ span,.popup-content .options-list input[type="checkbox"].disabled ~ p,.sheets-content .options-list input[type="checkbox"].disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ p,.popup-content .options-list input[type="radio"].disabled ~ p,.sheets-content .options-list input[type="radio"].disabled ~ p,.modal-legacy.dark .options-list input[type="radio"].disabled ~ p,.popup-content .options-list input[type="checkbox"]:disabled ~ p,.sheets-content .options-list input[type="checkbox"]:disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ p,.popup-content .options-list input[type="radio"]:disabled ~ p,.sheets-content .options-list input[type="radio"]:disabled ~ p,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ p {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {border-radius: 8.5px;}.loading-indicator {display: inline-block;border-radius: 30px;-webkit-animation: loading 1.2s infinite linear;-moz-animation: loading 1.2s infinite linear;-o-animation: loading 1.2s infinite linear;-ms-animation: loading 1.2s infinite linear;animation: loading 1.2s infinite linear;width: 30px;height: 30px;border: 4px solid #0c92f3;border-top: 4px solid #e3e4e6;border-left: 4px solid #e3e4e6;vertical-align: middle;}.loading-indicator.small {margin-right: 10px;width: 16px;height: 16px;border: 2px solid #0c92f3;border-top: 2px solid #e3e4e6;border-left: 2px solid #e3e4e6;}.loading-indicator.small.completed {border: 2px solid #555659;}.loading-indicator.small.completed .icon {vertical-align: top;width: 10px;height: 10px;}.loading-indicator.completed {border: 4px solid #555659;text-align: center;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;}.loading-indicator .icon {margin-left: 1px;height: 100%;vertical-align: middle;}.loading-indicator .icon >path {fill: #39bf87;}.loading-indicator.fadein {-webkit-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-moz-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-o-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-ms-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}.css-icon {display: inline-block;width: 16px;height: 1px;}.css-icon::before {position: absolute;display: block;content: "";right: 10px;top: calc(50% - 8px);width: 16px;height: 16px;}.css-icon-plus::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path d='M7.5,3h1v4.5H13v1H8.5V13h-1V8.5H3v-1h4.5V3z'></path></svg>") no-repeat 0 0;}.css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23979797' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.btn-no-style.dark:hover .css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23DCDCDC' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.toggle-label {clear: left;color: #969799;line-height: 22px;}.toggle-label button {float: left;margin-right: 10px;}.toggle-slider {margin-left: 10px;background: #fff;width: 45px;height: 22px;border-radius: 11px;position: relative;vertical-align: middle;border: 1px solid #dcdcdc;-webkit-transition: background 150ms;-moz-transition: background 150ms;-o-transition: background 150ms;-ms-transition: background 150ms;transition: background 150ms;}.toggle-slider:focus {outline: none;}.toggle-slider:hover {background-color: #f9f9f9;}.toggle-slider .ball {height: 16px;width: 16px;border-radius: 8px;position: absolute;background-color: #dcdcdc;left: 2px;top: 2px;right: auto;-webkit-transition: 150ms;-moz-transition: 150ms;-o-transition: 150ms;-ms-transition: 150ms;transition: 150ms;}.toggle-slider .ball:hover {background: #969799;}.toggle-slider.on .ball {left: 25px;background: #39bf87;}.toggle-slider.on .ball:hover {background: #30a272;}.message-banner {position: relative;display: inline-block;margin-bottom: 20px;padding: 9px 15px;border-radius: 3px;background: #e1f3ff;color: #6a7c83;}.message-banner.full-width {display: block;}.message-banner.centered {text-align: center;}.message-banner.has-icon {padding-left: 41px;}.message-banner.has-dismiss {padding-right: 41px;}.message-banner.has-dismiss .icon-btn {position: absolute;right: 15px;top: 6px;}.message-banner.has-dismiss .icon-btn .icon {position: relative;left: inherit;top: inherit;}.message-banner.has-button {padding-top: 14px;padding-right: 180px;padding-bottom: 14px;}.message-banner.has-button .icon {top: 15px;}.message-banner.has-button .btn,.message-banner.has-button button {position: absolute;right: 10px;top: 10px;}.message-banner a,.message-banner a:visited {color: #555659;}.message-banner a:hover,.message-banner a:visited:hover {color: #1a1b1c;}.message-banner .icon {position: absolute;left: 15px;top: 10px;}.message-banner .icon >path {fill: #6a7c83;}.message-banner .label {color: #555659;}.message-banner .btn {float: right;}.message-banner.warning {background: #fec;}.message-banner.error {background: #ffe6e6;color: #555659;}.message-banner.error .label {color: #555659;}.message-banner.error .icon >path {fill: #555659;}.what-is-this {display: inline-block;color: #969799;cursor: default;padding-left: 4px;font-size: 12px;}.what-is-this.dark {color: #6a7c83;}.what-is-this.dark:hover {color: #f9f9f9;}.what-is-this .icon >path {fill: #969799;}.what-is-this:hover {color: #555659;}.what-is-this:hover .icon >path {fill: #555659;}.what-is-this-icon {display: inline-block;margin-left: 10px;}.what-is-this-icon .icon {width: 12px;height: 12px;}.what-is-this-icon .icon >path {fill: #969799;}.what-is-this-icon:hover .icon >path {fill: #555659;}.what-is-this-icon.no-margin {margin-left: 4px;}.what-is-this-icon.dark .icon >path {fill: #6a7c83;}.what-is-this-icon.dark:hover .icon >path {fill: #dde5e7;}.gated-feature,.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter,.gated-feature-block,.gated-feature-block-pro {position: relative;cursor: pointer;background: rgba(227,228,230,0.5);}.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before {content: 'Enterprise';font-size: 12px;color: #fff;background-color: #39bf87;border-radius: 3px;padding: 2px 10px;position: absolute;right: 15px;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {cursor: pointer;content: '';border-radius: 3px;border: 1px solid #e3e4e6;}.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter {border: 1px solid #e3e4e6;border-radius: 3px;}.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before {content: 'Enterprise';position: absolute;float: right;top: 50%;-webkit-transform: translateY(-50%);-moz-transform: translateY(-50%);-o-transform: translateY(-50%);-ms-transform: translateY(-50%);transform: translateY(-50%);margin-left: 10px;}.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after {content: none;display: none;}.gated-feature-inline *,.gated-feature-inline-enterprise *,.gated-feature-inline-professional *,.gated-feature-inline-starter * {pointer-events: none;}.gated-feature-inline-professional:before {content: 'Pro';}.gated-feature-inline-starter:before {content: 'Starter';}.gated-feature-block,.gated-feature-block-pro {margin-top: 32px;padding: 15px 15px;}.gated-feature-block:before,.gated-feature-block-pro:before {top: 15px;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;}.gated-feature-block:after,.gated-feature-block-pro:after {pointer-events: none;}.gated-feature-block-pro:before {content: 'Pro';}.gated-ad {max-width: 600px;min-height: 270px;}.gated-ad .pull-left {float: left;margin-right: 70px;}.gated-ad div.pull-left,.gated-ad div.image {margin-top: 25px;}.gated-ad ul li {margin: 0 0 32px 0;list-style: none;}.gated-ad ul li .icon {vertical-align: sub;margin-right: 10px;}.gated-ad ul li .icon > path {fill: #969799;}.momentum-body,.badge,.theme-inverse .button.button-link,.button.button-link,.font-base {font-family: 'Meta', sans-serif;letter-spacing: 0;text-transform: none;}.momentum-body .icon,.badge .icon,.theme-inverse .button.button-link .icon,.button.button-link .icon,.font-base .icon,.momentum-body .momentum-body .icon,.momentum-body .badge .icon,.momentum-body .theme-inverse .button.button-link .icon,.momentum-body .button.button-link .icon,.momentum-body .font-base .icon {vertical-align: -0.15em;}.momentum-body {color: #222326;font-size: 16px;font-weight: normal;line-height: 24px;margin: 0;}.button,.mo-identicon-initials,.col-list-row-header,.nav-link,.font-caps {font-family: 'Meta-Caps', 'Meta', sans-serif;letter-spacing: 1px;text-transform: lowercase;}.button .icon,.mo-identicon-initials .icon,.col-list-row-header .icon,.nav-link .icon,.font-caps .icon,.momentum-body .button .icon,.momentum-body .mo-identicon-initials .icon,.momentum-body .col-list-row-header .icon,.momentum-body .nav-link .icon,.momentum-body .font-caps .icon {vertical-align: -0.188em;}.form-control,.font-inherit {font-family: inherit;letter-spacing: inherit;text-transform: inherit;}.theme-inverse .button {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.theme-inverse,.theme-inverse .text-base,.theme-inverse .text-small,.theme-inverse .text-caption {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5,.momentum-body b,.momentum-body strong,.text-h1,.text-h2,.text-h3,.text-h3_5,.text-h4,.text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5,.theme-inverse b,.theme-inverse strong,.theme-inverse .text-h1,.theme-inverse .text-h2,.theme-inverse .text-h3,.theme-inverse .text-h3_5,.theme-inverse .text-h4,.theme-inverse .text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse {background-color: #3b3d3f;color: #d7d7d9;}.card {border-radius: 3px;-webkit-box-shadow: 0 1px 1px rgba(0,0,0,0.15);box-shadow: 0 1px 1px rgba(0,0,0,0.15);}.momentum-body p {margin-bottom: 16px;margin-top: 0;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5 {color: #222326;font-weight: bold;margin-bottom: 8px;margin-top: 0;text-transform: none;}.momentum-body h1 {font-size: 40px;line-height: 48px;}.momentum-body h2 {font-size: 32px;line-height: 40px;}.momentum-body h3 {font-size: 24px;line-height: 36px;}.momentum-body h4 {font-size: 16px;letter-spacing: 0;font-family: 'Meta', sans-serif;line-height: 24px;}.momentum-body h5 {font-size: 14px;line-height: 21px;}.momentum-body small {font-size: 14px;line-height: 21px;}.momentum-body ol,.momentum-body ul {margin-bottom: 16px;margin-top: 0;padding-left: 16px;}.momentum-body ol ol,.momentum-body ul ol,.momentum-body ol ul,.momentum-body ul ul {margin-bottom: 0;}.momentum-body b,.momentum-body strong {font-weight: bolder;}.momentum-body a {-webkit-text-decoration-skip: objects;background-color: transparent;color: inherit;text-decoration: underline;}.momentum-body a:visited {color: inherit;}.momentum-body a:hover {color: #0068b3;}.momentum-body a:active {color: #003459;}.momentum-body a.strikethrough {text-decoration: line-through;}.momentum-body a.text-muted {color: #555659;}.momentum-body a.text-decoration-none {text-decoration: none;}.momentum-body a.underline-on-hover {text-decoration: none;}.momentum-body a.underline-on-hover:hover,.momentum-body a.underline-on-hover:active,.momentum-body a.underline-on-hover:focus {text-decoration: underline;}.momentum-body hr {background: #e3e4e6;border: none;height: 1px;margin-bottom: 4px;margin-top: 3px;}.momentum-body section {margin-bottom: 32px;}.momentum-body input[type=text] {height: auto;}.momentum-body button {cursor: pointer;}.momentum-body .icon {display: inline-block;height: 16px;margin-left: 8px;margin-right: 8px;width: 16px;}.momentum-body .icon:not(.icon-ms-teams) > path {fill: currentColor;}.momentum-body .icon:first-child {margin-left: 0;}.momentum-body .icon:last-child {margin-right: 0;}.momentum-body .icon-large {height: 24px;margin-left: 8px;margin-right: 8px;width: 24px;}.momentum-body .icon-small {height: 14px;width: 14px;margin-left: 8px;margin-right: 8px;}.momentum-body .icon-caption {height: 12px;width: 12px;margin-left: 4px;margin-right: 4px;}.momentum-body .icon-thumbnail {height: 48px;margin-left: $iconThumbnailMarginX;margin-right: $iconThumbnailMarginX;width: 48px;}.badge {border-radius: 3px;display: inline-block;font-size: 14px;height: 20px;line-height: 20px;margin-left: 8px;margin-right: 8px;min-width: 20px;padding-left: 4px;padding-right: 4px;text-align: center;}.badge:first-child {margin-left: 0;}.badge:last-child {margin-right: 0;}.badge {background-color: #e3e4e6;color: #969799;}.theme-inverse .badge {background-color: #555659;color: #d7d7d9;}.theme-inverse .badge.badge-default {background-color: #e3e4e6;color: #969799;}.badge.badge-primary {background-color: #0c92f3;color: #fff;}.badge.badge-secondary {background-color: #969799;color: #fff;}.badge.badge-positive {background-color: #39bf71;color: #fff;}.badge.badge-negative {background-color: #d94141;color: #fff;}.badge.badge-inverse {background-color: #555659;color: #d7d7d9;}.badge.badge-white {background-color: #fff;color: #555659;}.badge.badge-gray {background-color: #969799;color: #fff;}.badge.badge-black {background-color: #000;color: #fff;}.badge.badge-small {font-size: 12px;height: 18px;line-height: 18px;min-width: 18px;}.badge.badge-caption {font-size: 12px;height: 16px;line-height: 16px;min-width: 16px;}.button,a.button {background-color: #fff;background-image: -webkit-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -moz-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -o-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -ms-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);border: 1px solid rgba(215,215,217,0.7);color: #555659;padding: 7px 15px;}.button:hover,a.button:hover,.button.hover,a.button.hover {background-color: #fff;border-color: #b1b1b3;color: #555659;}.button:focus,a.button:focus,.button.focus,a.button.focus {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.button:active,a.button:active,.button.active,a.button.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #222326;}.button.selected,a.button.selected {background-color: #e3e4e6;color: #222326;}.button[disabled],a.button[disabled],.button.disabled,a.button.disabled {cursor: not-allowed;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.button[disabled]:hover,a.button[disabled]:hover,.button.disabled:hover,a.button.disabled:hover,.button[disabled]:active,a.button[disabled]:active,.button.disabled:active,a.button.disabled:active {background-color: #fff;background-image: $buttonBackgroundGradient;border-color: rgba(215,215,217,0.7);color: #555659;}.button.button-square,a.button.button-square {padding: 7px 11px;}.button.button-lg,a.button.button-lg {padding: 5px 15px;}.button.button-lg.button-square,a.button.button-lg.button-square {padding: 5px 14px;}.button.button-sm,a.button.button-sm {padding: 3px 15px;}.button.button-sm.button-square,a.button.button-sm.button-square {padding: 3px 8px;}.button-group .button:hover,.button-group a.button:hover {border-right-width: 1px;}.button-group .button:hover + .button,.button-group a.button:hover + .button {margin-left: 0;border-left-width: 0;}.button {border-radius: 3px;cursor: pointer;display: inline-block;font-size: 14px;line-height: 24px;margin-right: 8px;text-align: center;-webkit-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;}.button,.momentum-body .button {text-decoration: none;}.button:last-child {margin-right: 0;}.button .icon {margin-left: 12px;margin-right: 12px;opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);-webkit-transition: opacity 0.15s ease-in-out;-moz-transition: opacity 0.15s ease-in-out;-o-transition: opacity 0.15s ease-in-out;-ms-transition: opacity 0.15s ease-in-out;transition: opacity 0.15s ease-in-out;}.button .icon:first-child {margin-left: 0;}.button .icon:last-child {margin-right: 0;}.theme-inverse .button {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.theme-inverse .button .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button:visited {color: #fff;}.theme-inverse .button:hover,.theme-inverse .button.hover {background-color: #707173;border-color: #969799;color: #fff;}.theme-inverse .button:hover .icon,.theme-inverse .button.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.theme-inverse .button:active,.theme-inverse .button.active {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button.selected {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button[disabled]:hover,.theme-inverse .button.disabled:hover,.theme-inverse .button[disabled]:active,.theme-inverse .button.disabled:active {background-color: #555659;background-image: none;color: #fff;}.theme-inverse .button[disabled]:hover .icon,.theme-inverse .button.disabled:hover .icon,.theme-inverse .button[disabled]:active .icon,.theme-inverse .button.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button.button-square {padding: 8px 12px;}.theme-inverse .button.button-lg {padding: 6px 16px;}.theme-inverse .button.button-lg.button-square {padding: 6px 15px;}.theme-inverse .button.button-sm {padding: 4px 16px;}.theme-inverse .button.button-sm.button-square {padding: 4px 9px;}.button-group .theme-inverse .button:hover {border-right-width: 0;}.button-group .theme-inverse .button:hover + .button {margin-left: -1px;border-left-width: 1px;}.theme-inverse .button.button-link {border: none;background-color: transparent;background-image: none;color: #969799;padding: 0;text-decoration: underline;text-transform: none;}.theme-inverse .button.button-link:visited {color: #969799;}.theme-inverse .button.button-link:hover {color: #d7d7d9;}.theme-inverse .button.button-link:active {color: #0c92f3;}.theme-inverse .button.button-link.text-decoration-none {text-decoration: none;}.button.button-link {border: none;background-color: transparent;background-image: none;color: inherit;padding: 0;text-decoration: underline;text-transform: none;}.button.button-link:visited {color: inherit;}.button.button-link:hover {color: #0068b3;border: none;background-color: transparent;background-image: none;}.button.button-link:active {color: #003459;}.button.button-link.text-decoration-none {text-decoration: none;}.button.button-primary,.button.button-blue {background-color: #0c92f3;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-primary .icon,.button.button-blue .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:visited,.button.button-blue:visited {color: #fff;}.button.button-primary:hover,.button.button-blue:hover,.button.button-primary.hover,.button.button-blue.hover {background-color: #007fd9;border-color: #fff;color: #fff;}.button.button-primary:hover .icon,.button.button-blue:hover .icon,.button.button-primary.hover .icon,.button.button-blue.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:active,.button.button-blue:active,.button.button-primary.active,.button.button-blue.active {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary.selected,.button.button-blue.selected {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary[disabled]:hover,.button.button-blue[disabled]:hover,.button.button-primary.disabled:hover,.button.button-blue.disabled:hover,.button.button-primary[disabled]:active,.button.button-blue[disabled]:active,.button.button-primary.disabled:active,.button.button-blue.disabled:active {background-color: #0c92f3;background-image: none;color: #fff;}.button.button-primary[disabled]:hover .icon,.button.button-blue[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-blue.disabled:hover .icon,.button.button-primary[disabled]:active .icon,.button.button-blue[disabled]:active .icon,.button.button-primary.disabled:active .icon,.button.button-blue.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary.button-square,.button.button-blue.button-square {padding: 8px 12px;}.button.button-primary.button-lg,.button.button-blue.button-lg {padding: 6px 16px;}.button.button-primary.button-lg.button-square,.button.button-blue.button-lg.button-square {padding: 6px 15px;}.button.button-primary.button-sm,.button.button-blue.button-sm {padding: 4px 16px;}.button.button-primary.button-sm.button-square,.button.button-blue.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary:hover,.button-group .button.button-blue:hover {border-right-width: 0;}.button-group .button.button-primary:hover + .button,.button-group .button.button-blue:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-primary[disabled],.button.button-primary.disabled {background-color: #e3e4e6;background-image: none;border-color: #d7d7d9;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-primary[disabled] .icon,.button.button-primary.disabled .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled]:visited,.button.button-primary.disabled:visited {color: #555659;}.button.button-primary[disabled]:hover,.button.button-primary.disabled:hover,.button.button-primary[disabled].hover,.button.button-primary.disabled.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-primary[disabled].hover .icon,.button.button-primary.disabled.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary[disabled]:active,.button.button-primary.disabled:active,.button.button-primary[disabled].active,.button.button-primary.disabled.active {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled].selected,.button.button-primary.disabled.selected {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled][disabled]:hover,.button.button-primary.disabled[disabled]:hover,.button.button-primary[disabled].disabled:hover,.button.button-primary.disabled.disabled:hover,.button.button-primary[disabled][disabled]:active,.button.button-primary.disabled[disabled]:active,.button.button-primary[disabled].disabled:active,.button.button-primary.disabled.disabled:active {background-color: #e3e4e6;background-image: none;color: #555659;}.button.button-primary[disabled][disabled]:hover .icon,.button.button-primary.disabled[disabled]:hover .icon,.button.button-primary[disabled].disabled:hover .icon,.button.button-primary.disabled.disabled:hover .icon,.button.button-primary[disabled][disabled]:active .icon,.button.button-primary.disabled[disabled]:active .icon,.button.button-primary[disabled].disabled:active .icon,.button.button-primary.disabled.disabled:active .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled].button-square,.button.button-primary.disabled.button-square {padding: 8px 12px;}.button.button-primary[disabled].button-lg,.button.button-primary.disabled.button-lg {padding: 6px 16px;}.button.button-primary[disabled].button-lg.button-square,.button.button-primary.disabled.button-lg.button-square {padding: 6px 15px;}.button.button-primary[disabled].button-sm,.button.button-primary.disabled.button-sm {padding: 4px 16px;}.button.button-primary[disabled].button-sm.button-square,.button.button-primary.disabled.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary[disabled]:hover,.button-group .button.button-primary.disabled:hover {border-right-width: 0;}.button-group .button.button-primary[disabled]:hover + .button,.button-group .button.button-primary.disabled:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-positive,.button.button-green {background-color: #39bf71;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-positive .icon,.button.button-green .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:visited,.button.button-green:visited {color: #fff;}.button.button-positive:hover,.button.button-green:hover,.button.button-positive.hover,.button.button-green.hover {background-color: #19a654;border-color: #fff;color: #fff;}.button.button-positive:hover .icon,.button.button-green:hover .icon,.button.button-positive.hover .icon,.button.button-green.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:active,.button.button-green:active,.button.button-positive.active,.button.button-green.active {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive.selected,.button.button-green.selected {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive[disabled]:hover,.button.button-green[disabled]:hover,.button.button-positive.disabled:hover,.button.button-green.disabled:hover,.button.button-positive[disabled]:active,.button.button-green[disabled]:active,.button.button-positive.disabled:active,.button.button-green.disabled:active {background-color: #39bf71;background-image: none;color: #fff;}.button.button-positive[disabled]:hover .icon,.button.button-green[disabled]:hover .icon,.button.button-positive.disabled:hover .icon,.button.button-green.disabled:hover .icon,.button.button-positive[disabled]:active .icon,.button.button-green[disabled]:active .icon,.button.button-positive.disabled:active .icon,.button.button-green.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive.button-square,.button.button-green.button-square {padding: 8px 12px;}.button.button-positive.button-lg,.button.button-green.button-lg {padding: 6px 16px;}.button.button-positive.button-lg.button-square,.button.button-green.button-lg.button-square {padding: 6px 15px;}.button.button-positive.button-sm,.button.button-green.button-sm {padding: 4px 16px;}.button.button-positive.button-sm.button-square,.button.button-green.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-positive:hover,.button-group .button.button-green:hover {border-right-width: 0;}.button-group .button.button-positive:hover + .button,.button-group .button.button-green:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-negative,.button.button-red {background-color: #d94141;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-negative .icon,.button.button-red .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:visited,.button.button-red:visited {color: #fff;}.button.button-negative:hover,.button.button-red:hover,.button.button-negative.hover,.button.button-red.hover {background-color: #bf3939;border-color: #fff;color: #fff;}.button.button-negative:hover .icon,.button.button-red:hover .icon,.button.button-negative.hover .icon,.button.button-red.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:active,.button.button-red:active,.button.button-negative.active,.button.button-red.active {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative.selected,.button.button-red.selected {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative[disabled]:hover,.button.button-red[disabled]:hover,.button.button-negative.disabled:hover,.button.button-red.disabled:hover,.button.button-negative[disabled]:active,.button.button-red[disabled]:active,.button.button-negative.disabled:active,.button.button-red.disabled:active {background-color: #d94141;background-image: none;color: #fff;}.button.button-negative[disabled]:hover .icon,.button.button-red[disabled]:hover .icon,.button.button-negative.disabled:hover .icon,.button.button-red.disabled:hover .icon,.button.button-negative[disabled]:active .icon,.button.button-red[disabled]:active .icon,.button.button-negative.disabled:active .icon,.button.button-red.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative.button-square,.button.button-red.button-square {padding: 8px 12px;}.button.button-negative.button-lg,.button.button-red.button-lg {padding: 6px 16px;}.button.button-negative.button-lg.button-square,.button.button-red.button-lg.button-square {padding: 6px 15px;}.button.button-negative.button-sm,.button.button-red.button-sm {padding: 4px 16px;}.button.button-negative.button-sm.button-square,.button.button-red.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-negative:hover,.button-group .button.button-red:hover {border-right-width: 0;}.button-group .button.button-negative:hover + .button,.button-group .button.button-red:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-inverse,.button.button-gray {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-inverse .icon,.button.button-gray .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse:visited,.button.button-gray:visited {color: #fff;}.button.button-inverse:hover,.button.button-gray:hover,.button.button-inverse.hover,.button.button-gray.hover {background-color: #707173;border-color: #969799;color: #fff;}.button.button-inverse:hover .icon,.button.button-gray:hover .icon,.button.button-inverse.hover .icon,.button.button-gray.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-inverse:active,.button.button-gray:active,.button.button-inverse.active,.button.button-gray.active {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse.selected,.button.button-gray.selected {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse[disabled]:hover,.button.button-gray[disabled]:hover,.button.button-inverse.disabled:hover,.button.button-gray.disabled:hover,.button.button-inverse[disabled]:active,.button.button-gray[disabled]:active,.button.button-inverse.disabled:active,.button.button-gray.disabled:active {background-color: #555659;background-image: none;color: #fff;}.button.button-inverse[disabled]:hover .icon,.button.button-gray[disabled]:hover .icon,.button.button-inverse.disabled:hover .icon,.button.button-gray.disabled:hover .icon,.button.button-inverse[disabled]:active .icon,.button.button-gray[disabled]:active .icon,.button.button-inverse.disabled:active .icon,.button.button-gray.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse.button-square,.button.button-gray.button-square {padding: 8px 12px;}.button.button-inverse.button-lg,.button.button-gray.button-lg {padding: 6px 16px;}.button.button-inverse.button-lg.button-square,.button.button-gray.button-lg.button-square {padding: 6px 15px;}.button.button-inverse.button-sm,.button.button-gray.button-sm {padding: 4px 16px;}.button.button-inverse.button-sm.button-square,.button.button-gray.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-inverse:hover,.button-group .button.button-gray:hover {border-right-width: 0;}.button-group .button.button-inverse:hover + .button,.button-group .button.button-gray:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet {background-color: #a452cc;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-violet .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:visited {color: #fff;}.button.button-violet:hover,.button.button-violet.hover {background-color: #9c2bd4;border-color: #fff;color: #fff;}.button.button-violet:hover .icon,.button.button-violet.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:active,.button.button-violet.active {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet.selected {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet[disabled]:hover,.button.button-violet.disabled:hover,.button.button-violet[disabled]:active,.button.button-violet.disabled:active {background-color: #a452cc;background-image: none;color: #fff;}.button.button-violet[disabled]:hover .icon,.button.button-violet.disabled:hover .icon,.button.button-violet[disabled]:active .icon,.button.button-violet.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet.button-square {padding: 8px 12px;}.button.button-violet.button-lg {padding: 6px 16px;}.button.button-violet.button-lg.button-square {padding: 6px 15px;}.button.button-violet.button-sm {padding: 4px 16px;}.button.button-violet.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet:hover {border-right-width: 0;}.button-group .button.button-violet:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet-light {background-color: #f5e0ff;background-image: none;border-color: #f5e0ff;border-width: 0;color: #620e8c;padding: 8px 16px;}.button.button-violet-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light:visited {color: #620e8c;}.button.button-violet-light:hover,.button.button-violet-light.hover {background-color: #ebc4ff;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light:hover .icon,.button.button-violet-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet-light:active,.button.button-violet-light.active {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light.selected {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light[disabled]:hover,.button.button-violet-light.disabled:hover,.button.button-violet-light[disabled]:active,.button.button-violet-light.disabled:active {background-color: #f5e0ff;background-image: none;color: #620e8c;}.button.button-violet-light[disabled]:hover .icon,.button.button-violet-light.disabled:hover .icon,.button.button-violet-light[disabled]:active .icon,.button.button-violet-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light.button-square {padding: 8px 12px;}.button.button-violet-light.button-lg {padding: 6px 16px;}.button.button-violet-light.button-lg.button-square {padding: 6px 15px;}.button.button-violet-light.button-sm {padding: 4px 16px;}.button.button-violet-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet-light:hover {border-right-width: 0;}.button-group .button.button-violet-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-blue-light {background-color: #e1f3ff;background-image: none;border-color: #e1f3ff;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-blue-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light:visited {color: #555659;}.button.button-blue-light:hover,.button.button-blue-light.hover {background-color: #bfe5ff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light:hover .icon,.button.button-blue-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-blue-light:active,.button.button-blue-light.active {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light.selected {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light[disabled]:hover,.button.button-blue-light.disabled:hover,.button.button-blue-light[disabled]:active,.button.button-blue-light.disabled:active {background-color: #e1f3ff;background-image: none;color: #555659;}.button.button-blue-light[disabled]:hover .icon,.button.button-blue-light.disabled:hover .icon,.button.button-blue-light[disabled]:active .icon,.button.button-blue-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light.button-square {padding: 8px 12px;}.button.button-blue-light.button-lg {padding: 6px 16px;}.button.button-blue-light.button-lg.button-square {padding: 6px 15px;}.button.button-blue-light.button-sm {padding: 4px 16px;}.button.button-blue-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-blue-light:hover {border-right-width: 0;}.button-group .button.button-blue-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-turquoise {background-color: #1cadba;background-image: none;border-color: #1cadba;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-turquoise .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise:visited {color: #555659;}.button.button-turquoise:hover,.button.button-turquoise.hover {background-color: #0097a6;border-color: #1cadba;color: #555659;}.button.button-turquoise:hover .icon,.button.button-turquoise.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-turquoise:active,.button.button-turquoise.active {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise.selected {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise[disabled]:hover,.button.button-turquoise.disabled:hover,.button.button-turquoise[disabled]:active,.button.button-turquoise.disabled:active {background-color: #1cadba;background-image: none;color: #555659;}.button.button-turquoise[disabled]:hover .icon,.button.button-turquoise.disabled:hover .icon,.button.button-turquoise[disabled]:active .icon,.button.button-turquoise.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise.button-square {padding: 8px 12px;}.button.button-turquoise.button-lg {padding: 6px 16px;}.button.button-turquoise.button-lg.button-square {padding: 6px 15px;}.button.button-turquoise.button-sm {padding: 4px 16px;}.button.button-turquoise.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-turquoise:hover {border-right-width: 0;}.button-group .button.button-turquoise:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-yellow {background-color: #ffa60d;background-image: none;border-color: #ffa60d;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-yellow .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow:visited {color: #fff;}.button.button-yellow:hover,.button.button-yellow.hover {background-color: #ff9000;border-color: #ffa60d;color: #fff;}.button.button-yellow:hover .icon,.button.button-yellow.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-yellow:active,.button.button-yellow.active {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow.selected {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow[disabled]:hover,.button.button-yellow.disabled:hover,.button.button-yellow[disabled]:active,.button.button-yellow.disabled:active {background-color: #ffa60d;background-image: none;color: #fff;}.button.button-yellow[disabled]:hover .icon,.button.button-yellow.disabled:hover .icon,.button.button-yellow[disabled]:active .icon,.button.button-yellow.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow.button-square {padding: 8px 12px;}.button.button-yellow.button-lg {padding: 6px 16px;}.button.button-yellow.button-lg.button-square {padding: 6px 15px;}.button.button-yellow.button-sm {padding: 4px 16px;}.button.button-yellow.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-yellow:hover {border-right-width: 0;}.button-group .button.button-yellow:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-black {background-color: #000;background-image: none;border-color: #000;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-black .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black:visited {color: #fff;}.button.button-black:hover,.button.button-black.hover {background-color: #3b3d3f;border-color: #000;color: #fff;}.button.button-black:hover .icon,.button.button-black.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-black:active,.button.button-black.active {background-color: #555659;border-color: #000;color: #fff;}.button.button-black.selected {background-color: #555659;border-color: #000;color: #fff;}.button.button-black[disabled]:hover,.button.button-black.disabled:hover,.button.button-black[disabled]:active,.button.button-black.disabled:active {background-color: #000;background-image: none;color: #fff;}.button.button-black[disabled]:hover .icon,.button.button-black.disabled:hover .icon,.button.button-black[disabled]:active .icon,.button.button-black.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black.button-square {padding: 8px 12px;}.button.button-black.button-lg {padding: 6px 16px;}.button.button-black.button-lg.button-square {padding: 6px 15px;}.button.button-black.button-sm {padding: 4px 16px;}.button.button-black.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-black:hover {border-right-width: 0;}.button-group .button.button-black:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-lg {border-radius: 3px;font-size: 18px;line-height: 36px;}.button.button-lg .icon,.momentum-body .button.button-lg .icon {height: 18px;width: 18px;}.button.button-sm {border-radius: 3px;font-size: 14px;line-height: 24px;}.button.button-sm .icon,.momentum-body .button.button-sm .icon {height: 14px;width: 14px;}.button-group {margin-right: 8px;}.button-group:last-child {margin-right: 0;}.button-group .button {border-radius: 0;margin-right: 0;}.button-group .button:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.button-group .button:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.button-group .button + .button {border-left-width: 1px;margin-left: -1px;}.button-circle {border-radius: 50%;background-color: #fff;border: 0;padding: 12px 0;color: #969799;height: 46px;width: 46px;line-height: 23px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.button-circle >.icon {height: 23px;width: 23px;margin: auto;}.button-circle:hover {color: #fff;background-color: #0c92f3;}.button-circle,a.button-circle {display: inline-block;background: #fff;}.button-circle,.momentum-body .button-circle {text-decoration: none;}.button-circle.button-shadow {-webkit-box-shadow: 0px 1px 4px rgba(0,0,0,0.25);box-shadow: 0px 1px 4px rgba(0,0,0,0.25);}.button-circle.button-circle-sm {height: 28px;width: 28px;line-height: 14px;padding: 6px 7px 6px 5px;}.button-circle.button-circle-sm >.icon {height: 14px;width: 14px;}.button-circle.button-circle-lg {height: 56px;width: 56px;line-height: 28px;padding: 13px 0;}.button-circle.button-circle-lg >.icon {height: 28px;width: 28px;}.card {background-color: #fff;border: 1px solid #f0f1f2;padding: 16px;width: 100%;}.centered-content {align-items: center;display: flex;justify-content: center;}.ol-chain-list {padding: 8px 16px;border-radius: 3px;}.ol-chain-list .ol-chain-separator:not(:last-child) {border-bottom: 1px solid #d7d7d9;border-color: #d7d7d9;}.ol-chain-list .ol-chain-link {position: relative;padding: 8px 0;margin-left: 40px;}.ol-chain-list .ol-chain-link:before {position: absolute;top: 8px;bottom: -8px;border-color: #d7d7d9;border-style: dashed;border-width: 0 0 0 1px;content: "";left: -28px;}.ol-chain-list .ol-chain-link:last-child:before {display: none;}.ol-chain-list .ol-chain-link .ol-chain-counter {border: 1px solid #d7d7d9;border-radius: 50%;}.ol-chain-list .ol-chain-link .ol-chain-icon {align-items: center;display: flex;justify-content: center;padding-bottom: 4px;padding-top: 4px;}.ol-chain-list .ol-chain-link .ol-chain-counter,.ol-chain-list .ol-chain-link .ol-chain-icon {position: absolute;left: -40px;width: 24px;height: 24px;background: #fff;text-align: center;font-size: 14px;}.ol-chain-list .ol-chain-link .ol-chain-counter.optional,.ol-chain-list .ol-chain-link .ol-chain-icon.optional {border: 1px dotted #d7d7d9;}.ol-chain-list .ol-chain-link .ol-chain-content {width: 70%;}.ol-chain-list .ol-chain-link .ol-chain-content-100 {width: 100%;}.ol-chain-list .ol-chain-link .ol-chain-content-distributed {display: flex;justify-content: space-between;}.chip {border-radius: 12px;border-style: solid;border-width: 1px;display: inline-block;font-size: 14px;line-height: 14px;height: 24px;margin: 1px 4px 3px;max-width: 100%;overflow: hidden;padding: 4px 7px;-o-text-overflow: ellipsis;text-overflow: ellipsis;-webkit-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-moz-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-o-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-ms-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;vertical-align: middle;white-space: nowrap;}.chip,.momentum-body .chip {text-decoration: none;}.chip.chip-box {border-radius: 3px;}.chip:first-child {margin-left: 0;}.chip:last-child {margin-right: 0;}.chip + .chip {margin-left: 0;}.chip .icon {height: 1em;width: 1em;}.chip .icon,.chip .icon.momentum-body {margin-left: 0.5em;margin-right: 0.5em;}.chip > .close {color: inherit;}.chip > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 8px;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip > .close:hover {color: inherit;}.chip > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip > .close:active {color: inherit;}.chip > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip,.momentum-body  .chip {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}a.chip:hover,button.chip:hover,.chip.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}a.chip:active,button.chip:active,.chip.active {background-color: #b1b1b3;border-color: #b1b1b3;color: #555659;}a.chip:focus,button.chip:focus,.chip.focus {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip[disabled],.chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip[disabled]:hover,.chip.disabled:hover,.chip[disabled]:active,.chip.disabled:active {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined,.momentum-body  .chip.chip-outlined {background-color: #fff;border-color: #e3e4e6;color: #555659;}a.chip.chip-outlined:hover,button.chip.chip-outlined:hover,.chip.chip-outlined.hover {background-color: #f0f1f2;border-color: #d7d7d9;color: #555659;}a.chip.chip-outlined:active,button.chip.chip-outlined:active,.chip.chip-outlined.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #555659;}a.chip.chip-outlined:focus,button.chip.chip-outlined:focus,.chip.chip-outlined.focus {background-color: #fff;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined[disabled],.chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-outlined[disabled]:hover,.chip.chip-outlined.disabled:hover,.chip.chip-outlined[disabled]:active,.chip.chip-outlined.disabled:active {background-color: #fff;border-color: #e3e4e6;color: #555659;}.theme-inverse .chip,.momentum-body .theme-inverse .chip {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse a.chip:hover,.theme-inverse button.chip:hover,.theme-inverse .chip.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}.theme-inverse a.chip:active,.theme-inverse button.chip:active,.theme-inverse .chip.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip:focus,.theme-inverse button.chip:focus,.theme-inverse .chip.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip[disabled],.theme-inverse .chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip[disabled]:hover,.theme-inverse .chip.disabled:hover,.theme-inverse .chip[disabled]:active,.theme-inverse .chip.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip.chip-outlined,.momentum-body .theme-inverse .chip.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse a.chip.chip-outlined:hover,.theme-inverse button.chip.chip-outlined:hover,.theme-inverse .chip.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:active,.theme-inverse button.chip.chip-outlined:active,.theme-inverse .chip.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:focus,.theme-inverse button.chip.chip-outlined:focus,.theme-inverse .chip.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse .chip.chip-outlined[disabled],.theme-inverse .chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip.chip-outlined[disabled]:hover,.theme-inverse .chip.chip-outlined.disabled:hover,.theme-inverse .chip.chip-outlined[disabled]:active,.theme-inverse .chip.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse,.momentum-body  .chip.chip-inverse {background-color: #555659;border-color: #555659;color: #f0f1f2;}a.chip.chip-inverse:hover,button.chip.chip-inverse:hover,.chip.chip-inverse.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}a.chip.chip-inverse:active,button.chip.chip-inverse:active,.chip.chip-inverse.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse:focus,button.chip.chip-inverse:focus,.chip.chip-inverse.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse[disabled],.chip.chip-inverse.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse[disabled]:hover,.chip.chip-inverse.disabled:hover,.chip.chip-inverse[disabled]:active,.chip.chip-inverse.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse.chip-outlined,.momentum-body  .chip.chip-inverse.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}a.chip.chip-inverse.chip-outlined:hover,button.chip.chip-inverse.chip-outlined:hover,.chip.chip-inverse.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:active,button.chip.chip-inverse.chip-outlined:active,.chip.chip-inverse.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:focus,button.chip.chip-inverse.chip-outlined:focus,.chip.chip-inverse.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse.chip-outlined[disabled],.chip.chip-inverse.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse.chip-outlined[disabled]:hover,.chip.chip-inverse.chip-outlined.disabled:hover,.chip.chip-inverse.chip-outlined[disabled]:active,.chip.chip-inverse.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-blue,.momentum-body  .chip.chip-blue {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}a.chip.chip-blue:hover,button.chip.chip-blue:hover,.chip.chip-blue.hover {background-color: #bfe5ff;border-color: #bfe5ff;color: #555659;}a.chip.chip-blue:active,button.chip.chip-blue:active,.chip.chip-blue.active {background-color: #a6daff;border-color: #a6daff;color: #555659;}a.chip.chip-blue:focus,button.chip.chip-blue:focus,.chip.chip-blue.focus {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue[disabled],.chip.chip-blue.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue[disabled]:hover,.chip.chip-blue.disabled:hover,.chip.chip-blue[disabled]:active,.chip.chip-blue.disabled:active {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue.chip-outlined,.momentum-body  .chip.chip-blue.chip-outlined {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:hover,button.chip.chip-blue.chip-outlined:hover,.chip.chip-blue.chip-outlined.hover {background-color: #bfe5ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:active,button.chip.chip-blue.chip-outlined:active,.chip.chip-blue.chip-outlined.active {background-color: #a6daff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:focus,button.chip.chip-blue.chip-outlined:focus,.chip.chip-blue.chip-outlined.focus {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue.chip-outlined[disabled],.chip.chip-blue.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue.chip-outlined[disabled]:hover,.chip.chip-blue.chip-outlined.disabled:hover,.chip.chip-blue.chip-outlined[disabled]:active,.chip.chip-blue.chip-outlined.disabled:active {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue-dark,.momentum-body  .chip.chip-blue-dark {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}a.chip.chip-blue-dark:hover,button.chip.chip-blue-dark:hover,.chip.chip-blue-dark.hover {background-color: #0068b3;border-color: #0068b3;color: #f3faff;}a.chip.chip-blue-dark:active,button.chip.chip-blue-dark:active,.chip.chip-blue-dark.active {background-color: #004a7f;border-color: #004a7f;color: #f3faff;}a.chip.chip-blue-dark:focus,button.chip.chip-blue-dark:focus,.chip.chip-blue-dark.focus {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark[disabled],.chip.chip-blue-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark[disabled]:hover,.chip.chip-blue-dark.disabled:hover,.chip.chip-blue-dark[disabled]:active,.chip.chip-blue-dark.disabled:active {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark.chip-outlined,.momentum-body  .chip.chip-blue-dark.chip-outlined {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:hover,button.chip.chip-blue-dark.chip-outlined:hover,.chip.chip-blue-dark.chip-outlined.hover {background-color: #0068b3;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:active,button.chip.chip-blue-dark.chip-outlined:active,.chip.chip-blue-dark.chip-outlined.active {background-color: #004a7f;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:focus,button.chip.chip-blue-dark.chip-outlined:focus,.chip.chip-blue-dark.chip-outlined.focus {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-blue-dark.chip-outlined[disabled],.chip.chip-blue-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark.chip-outlined[disabled]:hover,.chip.chip-blue-dark.chip-outlined.disabled:hover,.chip.chip-blue-dark.chip-outlined[disabled]:active,.chip.chip-blue-dark.chip-outlined.disabled:active {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-red,.momentum-body  .chip.chip-red {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}a.chip.chip-red:hover,button.chip.chip-red:hover,.chip.chip-red.hover {background-color: #ffbfbf;border-color: #ffbfbf;color: #555659;}a.chip.chip-red:active,button.chip.chip-red:active,.chip.chip-red.active {background-color: #f99;border-color: #f99;color: #555659;}a.chip.chip-red:focus,button.chip.chip-red:focus,.chip.chip-red.focus {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red[disabled],.chip.chip-red.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red[disabled]:hover,.chip.chip-red.disabled:hover,.chip.chip-red[disabled]:active,.chip.chip-red.disabled:active {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red.chip-outlined,.momentum-body  .chip.chip-red.chip-outlined {background-color: #ffe6e6;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:hover,button.chip.chip-red.chip-outlined:hover,.chip.chip-red.chip-outlined.hover {background-color: #ffbfbf;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:active,button.chip.chip-red.chip-outlined:active,.chip.chip-red.chip-outlined.active {background-color: #f99;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:focus,button.chip.chip-red.chip-outlined:focus,.chip.chip-red.chip-outlined.focus {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red.chip-outlined[disabled],.chip.chip-red.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red.chip-outlined[disabled]:hover,.chip.chip-red.chip-outlined.disabled:hover,.chip.chip-red.chip-outlined[disabled]:active,.chip.chip-red.chip-outlined.disabled:active {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red-dark,.momentum-body  .chip.chip-red-dark {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}a.chip.chip-red-dark:hover,button.chip.chip-red-dark:hover,.chip.chip-red-dark.hover {background-color: #a62929;border-color: #a62929;color: #fff7f7;}a.chip.chip-red-dark:active,button.chip.chip-red-dark:active,.chip.chip-red-dark.active {background-color: #801a1a;border-color: #801a1a;color: #fff7f7;}a.chip.chip-red-dark:focus,button.chip.chip-red-dark:focus,.chip.chip-red-dark.focus {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark[disabled],.chip.chip-red-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark[disabled]:hover,.chip.chip-red-dark.disabled:hover,.chip.chip-red-dark[disabled]:active,.chip.chip-red-dark.disabled:active {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark.chip-outlined,.momentum-body  .chip.chip-red-dark.chip-outlined {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:hover,button.chip.chip-red-dark.chip-outlined:hover,.chip.chip-red-dark.chip-outlined.hover {background-color: #a62929;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:active,button.chip.chip-red-dark.chip-outlined:active,.chip.chip-red-dark.chip-outlined.active {background-color: #801a1a;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:focus,button.chip.chip-red-dark.chip-outlined:focus,.chip.chip-red-dark.chip-outlined.focus {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-red-dark.chip-outlined[disabled],.chip.chip-red-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark.chip-outlined[disabled]:hover,.chip.chip-red-dark.chip-outlined.disabled:hover,.chip.chip-red-dark.chip-outlined[disabled]:active,.chip.chip-red-dark.chip-outlined.disabled:active {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-green,.momentum-body  .chip.chip-green {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}a.chip.chip-green:hover,button.chip.chip-green:hover,.chip.chip-green.hover {background-color: #b4f0a8;border-color: #b4f0a8;color: #555659;}a.chip.chip-green:active,button.chip.chip-green:active,.chip.chip-green.active {background-color: #8ae58a;border-color: #8ae58a;color: #555659;}a.chip.chip-green:focus,button.chip.chip-green:focus,.chip.chip-green.focus {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green[disabled],.chip.chip-green.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green[disabled]:hover,.chip.chip-green.disabled:hover,.chip.chip-green[disabled]:active,.chip.chip-green.disabled:active {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green.chip-outlined,.momentum-body  .chip.chip-green.chip-outlined {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:hover,button.chip.chip-green.chip-outlined:hover,.chip.chip-green.chip-outlined.hover {background-color: #b4f0a8;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:active,button.chip.chip-green.chip-outlined:active,.chip.chip-green.chip-outlined.active {background-color: #8ae58a;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:focus,button.chip.chip-green.chip-outlined:focus,.chip.chip-green.chip-outlined.focus {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green.chip-outlined[disabled],.chip.chip-green.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green.chip-outlined[disabled]:hover,.chip.chip-green.chip-outlined.disabled:hover,.chip.chip-green.chip-outlined[disabled]:active,.chip.chip-green.chip-outlined.disabled:active {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green-dark,.momentum-body  .chip.chip-green-dark {background-color: #19a654;border-color: #19a654;color: #e1fae5;}a.chip.chip-green-dark:hover,button.chip.chip-green-dark:hover,.chip.chip-green-dark.hover {background-color: #0e8c42;border-color: #0e8c42;color: #e1fae5;}a.chip.chip-green-dark:active,button.chip.chip-green-dark:active,.chip.chip-green-dark.active {background-color: #007343;border-color: #007343;color: #e1fae5;}a.chip.chip-green-dark:focus,button.chip.chip-green-dark:focus,.chip.chip-green-dark.focus {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark[disabled],.chip.chip-green-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark[disabled]:hover,.chip.chip-green-dark.disabled:hover,.chip.chip-green-dark[disabled]:active,.chip.chip-green-dark.disabled:active {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark.chip-outlined,.momentum-body  .chip.chip-green-dark.chip-outlined {background-color: #19a654;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:hover,button.chip.chip-green-dark.chip-outlined:hover,.chip.chip-green-dark.chip-outlined.hover {background-color: #0e8c42;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:active,button.chip.chip-green-dark.chip-outlined:active,.chip.chip-green-dark.chip-outlined.active {background-color: #007343;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:focus,button.chip.chip-green-dark.chip-outlined:focus,.chip.chip-green-dark.chip-outlined.focus {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-green-dark.chip-outlined[disabled],.chip.chip-green-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark.chip-outlined[disabled]:hover,.chip.chip-green-dark.chip-outlined.disabled:hover,.chip.chip-green-dark.chip-outlined[disabled]:active,.chip.chip-green-dark.chip-outlined.disabled:active {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-yellow,.momentum-body  .chip.chip-yellow {background-color: #fec;border-color: #fec;color: #555659;}a.chip.chip-yellow:hover,button.chip.chip-yellow:hover,.chip.chip-yellow.hover {background-color: #ffe5b2;border-color: #ffe5b2;color: #555659;}a.chip.chip-yellow:active,button.chip.chip-yellow:active,.chip.chip-yellow.active {background-color: #ffdf88;border-color: #ffdf88;color: #555659;}a.chip.chip-yellow:focus,button.chip.chip-yellow:focus,.chip.chip-yellow.focus {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow[disabled],.chip.chip-yellow.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow[disabled]:hover,.chip.chip-yellow.disabled:hover,.chip.chip-yellow[disabled]:active,.chip.chip-yellow.disabled:active {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow.chip-outlined,.momentum-body  .chip.chip-yellow.chip-outlined {background-color: #fec;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:hover,button.chip.chip-yellow.chip-outlined:hover,.chip.chip-yellow.chip-outlined.hover {background-color: #ffe5b2;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:active,button.chip.chip-yellow.chip-outlined:active,.chip.chip-yellow.chip-outlined.active {background-color: #ffdf88;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:focus,button.chip.chip-yellow.chip-outlined:focus,.chip.chip-yellow.chip-outlined.focus {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow.chip-outlined[disabled],.chip.chip-yellow.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow.chip-outlined[disabled]:hover,.chip.chip-yellow.chip-outlined.disabled:hover,.chip.chip-yellow.chip-outlined[disabled]:active,.chip.chip-yellow.chip-outlined.disabled:active {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow-dark,.momentum-body  .chip.chip-yellow-dark {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}a.chip.chip-yellow-dark:hover,button.chip.chip-yellow-dark:hover,.chip.chip-yellow-dark.hover {background-color: #e67600;border-color: #e67600;color: #fff6e5;}a.chip.chip-yellow-dark:active,button.chip.chip-yellow-dark:active,.chip.chip-yellow-dark.active {background-color: #cc5f00;border-color: #cc5f00;color: #fff6e5;}a.chip.chip-yellow-dark:focus,button.chip.chip-yellow-dark:focus,.chip.chip-yellow-dark.focus {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark[disabled],.chip.chip-yellow-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark[disabled]:hover,.chip.chip-yellow-dark.disabled:hover,.chip.chip-yellow-dark[disabled]:active,.chip.chip-yellow-dark.disabled:active {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined,.momentum-body  .chip.chip-yellow-dark.chip-outlined {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:hover,button.chip.chip-yellow-dark.chip-outlined:hover,.chip.chip-yellow-dark.chip-outlined.hover {background-color: #e67600;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:active,button.chip.chip-yellow-dark.chip-outlined:active,.chip.chip-yellow-dark.chip-outlined.active {background-color: #cc5f00;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:focus,button.chip.chip-yellow-dark.chip-outlined:focus,.chip.chip-yellow-dark.chip-outlined.focus {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined[disabled],.chip.chip-yellow-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark.chip-outlined[disabled]:hover,.chip.chip-yellow-dark.chip-outlined.disabled:hover,.chip.chip-yellow-dark.chip-outlined[disabled]:active,.chip.chip-yellow-dark.chip-outlined.disabled:active {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-violet,.momentum-body  .chip.chip-violet {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}a.chip.chip-violet:hover,button.chip.chip-violet:hover,.chip.chip-violet.hover {background-color: #ebc4ff;border-color: #ebc4ff;color: #555659;}a.chip.chip-violet:active,button.chip.chip-violet:active,.chip.chip-violet.active {background-color: #dea2fc;border-color: #dea2fc;color: #555659;}a.chip.chip-violet:focus,button.chip.chip-violet:focus,.chip.chip-violet.focus {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet[disabled],.chip.chip-violet.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet[disabled]:hover,.chip.chip-violet.disabled:hover,.chip.chip-violet[disabled]:active,.chip.chip-violet.disabled:active {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet.chip-outlined,.momentum-body  .chip.chip-violet.chip-outlined {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:hover,button.chip.chip-violet.chip-outlined:hover,.chip.chip-violet.chip-outlined.hover {background-color: #ebc4ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:active,button.chip.chip-violet.chip-outlined:active,.chip.chip-violet.chip-outlined.active {background-color: #dea2fc;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:focus,button.chip.chip-violet.chip-outlined:focus,.chip.chip-violet.chip-outlined.focus {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-violet.chip-outlined[disabled],.chip.chip-violet.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet.chip-outlined[disabled]:hover,.chip.chip-violet.chip-outlined.disabled:hover,.chip.chip-violet.chip-outlined[disabled]:active,.chip.chip-violet.chip-outlined.disabled:active {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-turquoise,.momentum-body  .chip.chip-turquoise {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}a.chip.chip-turquoise:hover,button.chip.chip-turquoise:hover,.chip.chip-turquoise.hover {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise:active,button.chip.chip-turquoise:active,.chip.chip-turquoise.active {background-color: #91eaf2;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise:focus,button.chip.chip-turquoise:focus,.chip.chip-turquoise.focus {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise[disabled],.chip.chip-turquoise.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise[disabled]:hover,.chip.chip-turquoise.disabled:hover,.chip.chip-turquoise[disabled]:active,.chip.chip-turquoise.disabled:active {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}.chip.chip-turquoise.chip-outlined,.momentum-body  .chip.chip-turquoise.chip-outlined {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise.chip-outlined:hover,button.chip.chip-turquoise.chip-outlined:hover,.chip.chip-turquoise.chip-outlined.hover {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise.chip-outlined:active,button.chip.chip-turquoise.chip-outlined:active,.chip.chip-turquoise.chip-outlined.active {background-color: #91eaf2;border-color: #33c0cd;color: #222326;}a.chip.chip-turquoise.chip-outlined:focus,button.chip.chip-turquoise.chip-outlined:focus,.chip.chip-turquoise.chip-outlined.focus {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}.chip.chip-turquoise.chip-outlined[disabled],.chip.chip-turquoise.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise.chip-outlined[disabled]:hover,.chip.chip-turquoise.chip-outlined.disabled:hover,.chip.chip-turquoise.chip-outlined[disabled]:active,.chip.chip-turquoise.chip-outlined.disabled:active {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise.closable.closable-wide > .close::after {color: #555659;}.chip.chip-turquoise.closable.closable-wide > .close:hover::after {background-color: #91eaf2;}.chip.chip-turquoise.closable.closable-wide > .close:active::after {background-color: #33c0cd;}.chip.chip-lg {border-radius: 16px;font-size: 16px;height: 32px;line-height: 16px;padding: 7px 11px;}.chip.chip-lg.chip-box {border-radius: 3px;}.chip.chip-lg > .close::after {font-size: 13px;margin-left: 8px;}.chip.chip-sm {border-radius: 8px;font-size: 12px;height: 16px;line-height: 12px;padding: 1px 7px;}.chip.chip-sm.chip-box {border-radius: 3px;}.chip.chip-sm > .close::after {font-size: 9px;margin-left: 4px;}.chip.closable {padding-right: 20px;position: relative;}.chip.closable.closable-wide {align-items: center;display: inline-flex;padding-right: 8px;}.chip.closable.closable-wide > .close {position: relative;right: auto;}.chip.closable.closable-wide > .close::after {align-items: center;border-radius: 3px;display: inline-flex;justify-content: center;margin-left: 8px;opacity: 1;-ms-filter: none;filter: none;height: 16px;width: 16px;}.chip.closable.closable-wide > .close:hover::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide > .close:focus::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide.chip-lg {padding-right: 8px;}.chip.closable.closable-wide.chip-lg > .close::after {margin-left: 8px;height: 20px;width: 20px;}.chip.closable.closable-wide.chip-sm {padding-right: 4px;}.chip.closable.closable-wide.chip-sm > .close::after {margin-left: 4px;height: 12px;width: 12px;}.chip.closable > .close {color: inherit;position: absolute;right: 8px;text-decoration: none;}.chip.closable > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 0;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip.closable > .close:hover {color: inherit;}.chip.closable > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip.closable > .close:active {color: inherit;}.chip.closable > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip.closable.chip-lg {padding-right: 22px;}.chip.closable.chip-lg > .close::after {font-size: 13px;}.chip.closable.chip-sm {padding-right: 19px;}.chip.closable.chip-sm > .close::after {font-size: 9px;}.display-on-hover .displayed-on-hover {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.display-on-hover:hover .displayed-on-hover {opacity: 1;-ms-filter: none;filter: none;-webkit-transition: opacity 200ms ease-in-out;-moz-transition: opacity 200ms ease-in-out;-o-transition: opacity 200ms ease-in-out;-ms-transition: opacity 200ms ease-in-out;transition: opacity 200ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-fast {-webkit-transition: opacity 100ms ease-in-out;-moz-transition: opacity 100ms ease-in-out;-o-transition: opacity 100ms ease-in-out;-ms-transition: opacity 100ms ease-in-out;transition: opacity 100ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-slow {-webkit-transition: opacity 500ms ease-in-out;-moz-transition: opacity 500ms ease-in-out;-o-transition: opacity 500ms ease-in-out;-ms-transition: opacity 500ms ease-in-out;transition: opacity 500ms ease-in-out;}.text-divider {display: flex;align-items: center;text-align: center;}.text-divider::before,.text-divider::after {content: '';flex: 1;border-bottom: 1px solid #e3e4e6;}.text-divider:not(:empty)::before {margin-right: 8px;}.text-divider:not(:empty)::after {margin-left: 8px;}.marginless-divider {border-bottom: 1px solid #e3e4e6;}.form-group {margin-bottom: 24px;}.form-group label {display: block;font-size: 16px;margin-bottom: 4px;color: #222326;line-height: 24px;}.form-control,.form-control[disabled]:hover,.form-control.disabled:hover,.form-control.form-control-outlined,.theme-inverse .form-control.form-control-outlined,.form-control.form-control-outlined[disabled]:hover,.theme-inverse .form-control.form-control-outlined[disabled]:hover,.form-control.form-control-outlined.disabled:hover,.theme-inverse .form-control.form-control-outlined.disabled:hover {background-color: #fff;border-color: #e3e4e6;color: #222326;}.form-control::placeholder,.form-control[disabled]:hover::placeholder,.form-control.disabled:hover::placeholder,.form-control.form-control-outlined::placeholder,.theme-inverse .form-control.form-control-outlined::placeholder,.form-control.form-control-outlined[disabled]:hover::placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover::placeholder,.form-control.form-control-outlined.disabled:hover::placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover::placeholder,.form-control .form-control-placeholder,.form-control[disabled]:hover .form-control-placeholder,.form-control.disabled:hover .form-control-placeholder,.form-control.form-control-outlined .form-control-placeholder,.theme-inverse .form-control.form-control-outlined .form-control-placeholder,.form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.form-control.form-control-outlined.disabled:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover .form-control-placeholder {color: #555659;}.form-control:hover,.form-control.hover,.form-control.form-control-transparent:hover,.form-control.form-control-transparent.hover,.form-control.form-control-outlined:hover,.theme-inverse .form-control.form-control-outlined:hover,.form-control.form-control-outlined.hover,.theme-inverse .form-control.form-control-outlined.hover {background-color: #fff;border-color: #b1b1b3;color: #222326;}.theme-inverse .form-control,.theme-inverse .form-control[disabled]:hover,.theme-inverse .form-control.disabled:hover {background-color: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);color: #d7d7d9;}.theme-inverse .form-control::placeholder,.theme-inverse .form-control[disabled]:hover::placeholder,.theme-inverse .form-control.disabled:hover::placeholder,.theme-inverse .form-control .form-control-placeholder,.theme-inverse .form-control[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.disabled:hover .form-control-placeholder {color: #b1b1b3;}.theme-inverse .form-control:hover,.theme-inverse .form-control.hover {background-color: rgba(215,215,217,0.4);border-color: rgba(215,215,217,0);color: #d7d7d9;}.form-control.invalid,.form-control.invalid[disabled]:hover,.form-control.invalid.disabled:hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.invalid::placeholder,.form-control.invalid[disabled]:hover::placeholder,.form-control.invalid.disabled:hover::placeholder,.form-control.invalid .form-control-placeholder,.form-control.invalid[disabled]:hover .form-control-placeholder,.form-control.invalid.disabled:hover .form-control-placeholder {color: #555659;}.form-control.invalid:hover,.form-control.invalid.hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid,.theme-inverse .form-control.invalid[disabled]:hover,.theme-inverse .form-control.invalid.disabled:hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid::placeholder,.theme-inverse .form-control.invalid[disabled]:hover::placeholder,.theme-inverse .form-control.invalid.disabled:hover::placeholder,.theme-inverse .form-control.invalid .form-control-placeholder,.theme-inverse .form-control.invalid[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.invalid.disabled:hover .form-control-placeholder {color: #f99;}.theme-inverse .form-control.invalid:hover,.theme-inverse .form-control.invalid.hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.form-control-transparent,.form-control.form-control-transparent[disabled]:hover,.form-control.form-control-transparent.disabled:hover {background-color: transparent;border-color: transparent;color: inherit;}.form-control:focus,.form-control.focus,.form-control.form-control-transparent:focus,.form-control.form-control-transparent.focus,.theme-inverse .form-control:focus,.theme-inverse .form-control.focus,.form-control.form-control-outlined:focus,.theme-inverse .form-control.form-control-outlined:focus,.form-control.form-control-outlined.focus,.theme-inverse .form-control.form-control-outlined.focus,.form-control.invalid:focus,.form-control.invalid.focus,.theme-inverse .form-control.invalid:focus,.theme-inverse .form-control.invalid.focus {background-color: #fff;border-color: #0c92f3;color: #222326;}.form-control:focus::placeholder,.form-control.focus::placeholder,.form-control.form-control-transparent:focus::placeholder,.form-control.form-control-transparent.focus::placeholder,.theme-inverse .form-control:focus::placeholder,.theme-inverse .form-control.focus::placeholder,.form-control.form-control-outlined:focus::placeholder,.theme-inverse .form-control.form-control-outlined:focus::placeholder,.form-control.form-control-outlined.focus::placeholder,.theme-inverse .form-control.form-control-outlined.focus::placeholder,.form-control.invalid:focus::placeholder,.form-control.invalid.focus::placeholder,.theme-inverse .form-control.invalid:focus::placeholder,.theme-inverse .form-control.invalid.focus::placeholder,.form-control:focus .form-control-placeholder,.form-control.focus .form-control-placeholder,.form-control.form-control-transparent:focus .form-control-placeholder,.form-control.form-control-transparent.focus .form-control-placeholder,.theme-inverse .form-control:focus .form-control-placeholder,.theme-inverse .form-control.focus .form-control-placeholder,.form-control.form-control-outlined:focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined:focus .form-control-placeholder,.form-control.form-control-outlined.focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.focus .form-control-placeholder,.form-control.invalid:focus .form-control-placeholder,.form-control.invalid.focus .form-control-placeholder,.theme-inverse .form-control.invalid:focus .form-control-placeholder,.theme-inverse .form-control.invalid.focus .form-control-placeholder {color: #555659;}.form-control-label,label.form-control-label {display: block;line-height: 24px;font-size: 16px;margin-bottom: 4px;color: #222326;}.form-control-helper-text {display: block;margin-bottom: 4px;color: #222326;font-size: 14px;line-height: 21px;}.theme-inverse .form-group label,.theme-inverse .form-control-label,.theme-inverse label.form-control-label,.theme-inverse .form-control-helper-text {color: #d7d7d9;}.form-control {border-radius: 3px;border-style: solid;border-width: 1px;display: block;font-size: 16px;line-height: 24px;padding: 7px 15px;resize: vertical;-webkit-transition: border-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out;width: 100%;}.form-control:focus,.form-control.focus {outline: 0;}.form-control[disabled],.form-control.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-control.multi-select-input {padding: 6px 15px;}input.form-control {height: 40px;}.form-control-inline {display: inline-block;width: auto;}.form-control-inherit {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;color: inherit;font-size: inherit;font-weight: inherit;line-height: inherit;margin: -1px -8px;padding: 0 7px;}.form-control-inherit,input.form-control-inherit {height: auto;}.form-control-inherit.form-control-inline {margin-left: 0;margin-right: 0;}.form-control-lg {border-radius: 3px;font-size: 32px;line-height: 40px;padding: 3px 15px;}input.form-control-lg {height: 48px;}.form-control-sm {border-radius: 3px;font-size: 14px;line-height: 21px;padding: 4.5px 15px;}.form-control-sm.multi-select-input {padding: 3.5px 15px;}input.form-control-sm {height: 32px;}.form-check {display: block;}.form-check + .form-check {margin-top: 8px;}.form-check.disabled,.form-check [disabled] {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-check-label {display: inline-block;min-height: 24px;padding-left: 24px;position: relative;vertical-align: top;}.form-check-label .form-text {margin-top: 0;}.form-group label.form-check-label {display: inline-block;margin-bottom: 0;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {-moz-appearance: none;-webkit-appearance: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;border-style: solid;border-width: 1px;display: inline-block;height: 16px;margin: 0;position: relative;vertical-align: -0.15em;width: 16px;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);}.form-check-input:hover,input[type=checkbox].form-check-input:hover,input[type=radio].form-check-input:hover,.form-check.hover .form-check-input,.form-check.hover input[type=checkbox].form-check-input,.form-check.hover input[type=radio].form-check-input {background: rgba(150,151,153,0.4);border-color: #b1b1b3;}.form-check-input:active,input[type=checkbox].form-check-input:active,input[type=radio].form-check-input:active,.form-check.active .form-check-input,.form-check.active input[type=checkbox].form-check-input,.form-check.active input[type=radio].form-check-input {background: rgba(112,113,115,0.4);border-color: #969799;}.form-check-input:checked,input[type=checkbox].form-check-input:checked,input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input:checked:hover,input[type=checkbox].form-check-input:checked:hover,input[type=radio].form-check-input:checked:hover,.form-check.hover .form-check-input:checked,.form-check.hover input[type=checkbox].form-check-input:checked,.form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.form-check-input:checked:active,input[type=checkbox].form-check-input:checked:active,input[type=radio].form-check-input:checked:active,.form-check.active .form-check-input:checked,.form-check.active input[type=checkbox].form-check-input:checked,.form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.form-check-input[disabled]:hover,input[type=checkbox].form-check-input[disabled]:hover,input[type=radio].form-check-input[disabled]:hover,.form-check-input:indeterminate:hover,input[type=checkbox].form-check-input:indeterminate:hover,input[type=radio].form-check-input:indeterminate:hover,.form-check.disabled .form-check-input:hover,.form-check.disabled input[type=checkbox].form-check-input:hover,.form-check.disabled input[type=radio].form-check-input:hover,.form-check-input[disabled]:active,input[type=checkbox].form-check-input[disabled]:active,input[type=radio].form-check-input[disabled]:active,.form-check-input:indeterminate:active,input[type=checkbox].form-check-input:indeterminate:active,input[type=radio].form-check-input:indeterminate:active,.form-check.disabled .form-check-input:active,.form-check.disabled input[type=checkbox].form-check-input:active,.form-check.disabled input[type=radio].form-check-input:active {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);cursor: default;}.form-check-input[disabled]:checked,input[type=checkbox].form-check-input[disabled]:checked,input[type=radio].form-check-input[disabled]:checked,.form-check-input:indeterminate:checked,input[type=checkbox].form-check-input:indeterminate:checked,input[type=radio].form-check-input:indeterminate:checked,.form-check.disabled .form-check-input:checked,.form-check.disabled input[type=checkbox].form-check-input:checked,.form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-label .form-check-input,.form-check-label input[type=checkbox].form-check-input,.form-check-label input[type=radio].form-check-input {left: 0;position: absolute;top: 3px;}.form-check-input:focus,input[type=checkbox].form-check-input:focus,input[type=radio].form-check-input:focus {outline: 0;}.theme-inverse .form-check-input,.theme-inverse input[type=checkbox].form-check-input,.theme-inverse input[type=radio].form-check-input {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;}.theme-inverse .form-check-input:hover,.theme-inverse input[type=checkbox].form-check-input:hover,.theme-inverse input[type=radio].form-check-input:hover,.theme-inverse .form-check.hover .form-check-input,.theme-inverse .form-check.hover input[type=checkbox].form-check-input,.theme-inverse .form-check.hover input[type=radio].form-check-input {background: $formCheckOutlinedHoverBackgroundInverse;border-color: $formCheckOutlinedHoverBorderColorInverse;}.theme-inverse .form-check-input:active,.theme-inverse input[type=checkbox].form-check-input:active,.theme-inverse input[type=radio].form-check-input:active,.theme-inverse .form-check.active .form-check-input,.theme-inverse .form-check.active input[type=checkbox].form-check-input,.theme-inverse .form-check.active input[type=radio].form-check-input {background: $formCheckOutlinedActiveBackgroundInverse;border-color: $formCheckOutlinedActiveBorderColorInverse;}.theme-inverse .form-check-input:checked,.theme-inverse input[type=checkbox].form-check-input:checked,.theme-inverse input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.theme-inverse .form-check-input:checked:hover,.theme-inverse input[type=checkbox].form-check-input:checked:hover,.theme-inverse input[type=radio].form-check-input:checked:hover,.theme-inverse .form-check.hover .form-check-input:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.theme-inverse .form-check-input:checked:active,.theme-inverse input[type=checkbox].form-check-input:checked:active,.theme-inverse input[type=radio].form-check-input:checked:active,.theme-inverse .form-check.active .form-check-input:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.theme-inverse .form-check-input[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input[disabled]:hover,.theme-inverse input[type=radio].form-check-input[disabled]:hover,.theme-inverse .form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input:hover,.theme-inverse .form-check-input[disabled]:active,.theme-inverse input[type=checkbox].form-check-input[disabled]:active,.theme-inverse input[type=radio].form-check-input[disabled]:active,.theme-inverse .form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input:active {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;cursor: default;}.theme-inverse .form-check-input[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input[disabled]:checked,.theme-inverse input[type=radio].form-check-input[disabled]:checked,.theme-inverse .form-check-input:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input:indeterminate:checked,.theme-inverse input[type=radio].form-check-input:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined,input[type=checkbox].form-check-input.form-check-input-outlined,input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #e3e4e6;}.form-check-input.form-check-input-outlined:hover,input[type=checkbox].form-check-input.form-check-input-outlined:hover,input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check.hover .form-check-input.form-check-input-outlined,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #b1b1b3;}.form-check-input.form-check-input-outlined:active,input[type=checkbox].form-check-input.form-check-input-outlined:active,input[type=radio].form-check-input.form-check-input-outlined:active,.form-check.active .form-check-input.form-check-input-outlined,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.active input[type=radio].form-check-input.form-check-input-outlined {background: #f0f1f2;border-color: #969799;}.form-check-input.form-check-input-outlined:checked,input[type=checkbox].form-check-input.form-check-input-outlined:checked,input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined:checked:hover,input[type=checkbox].form-check-input.form-check-input-outlined:checked:hover,input[type=radio].form-check-input.form-check-input-outlined:checked:hover,.form-check.hover .form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined:checked {background: #007fd9;}.form-check-input.form-check-input-outlined:checked:active,input[type=checkbox].form-check-input.form-check-input-outlined:checked:active,input[type=radio].form-check-input.form-check-input-outlined:checked:active,.form-check.active .form-check-input.form-check-input-outlined:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.active input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0068b3;}.form-check-input.form-check-input-outlined[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:hover,input[type=radio].form-check-input.form-check-input-outlined[disabled]:hover,.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check-input.form-check-input-outlined[disabled]:active,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:active,input[type=radio].form-check-input.form-check-input-outlined[disabled]:active,.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:active {background: #fff;border-color: #e3e4e6;cursor: default;}.form-check-input.form-check-input-outlined[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:checked,input[type=radio].form-check-input.form-check-input-outlined[disabled]:checked,.form-check-input.form-check-input-outlined:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:checked,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.4945L7.97802 2.21978L4.85714 3.27472V0H3.53846V3.27472L0.417582 2.21978L0 3.4945L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.4945Z' fill='%23B1B1B3'/%3E%3C/svg%3E%0A");padding: 3px;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:hover,input[type=checkbox].form-check-input.form-check-input-required:hover,input[type=radio].form-check-input.form-check-input-required:hover,.form-check.hover .form-check-input.form-check-input-required,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required,.form-check.hover input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:active,input[type=checkbox].form-check-input.form-check-input-required:active,input[type=radio].form-check-input.form-check-input-required:active,.form-check.active .form-check-input.form-check-input-required,.form-check.active input[type=checkbox].form-check-input.form-check-input-required,.form-check.active input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked:hover,input[type=checkbox].form-check-input.form-check-input-required:checked:hover,input[type=radio].form-check-input.form-check-input-required:checked:hover,.form-check.hover .form-check-input.form-check-input-required:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-required:checked {background: #d94141;}.form-check-input.form-check-input-required:checked:active,input[type=checkbox].form-check-input.form-check-input-required:checked:active,input[type=radio].form-check-input.form-check-input-required:checked:active,.form-check.active .form-check-input.form-check-input-required:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.active input[type=radio].form-check-input.form-check-input-required:checked {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #f26161;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #d94141;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #bf3939;}.form-check-input.form-check-input-required[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-required[disabled]:hover,input[type=radio].form-check-input.form-check-input-required[disabled]:hover,.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-required:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:hover,.form-check-input.form-check-input-required[disabled]:active,input[type=checkbox].form-check-input.form-check-input-required[disabled]:active,input[type=radio].form-check-input.form-check-input-required[disabled]:active,.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-required:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:active {background: ;border-color: ;cursor: default;}.form-check-input.form-check-input-required[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-required[disabled]:checked,input[type=radio].form-check-input.form-check-input-required[disabled]:checked,.form-check-input.form-check-input-required:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:checked,input[type=radio].form-check-input.form-check-input-required:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-required:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.49451L7.97802 2.21978L4.85714 3.27473V0H3.53846V3.27473L0.417582 2.21978L0 3.49451L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.49451Z' fill='white'/%3E%3C/svg%3E%0A");}.form-check-input.invalid,input[type=checkbox].form-check-input.invalid,input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.form-check-input.invalid:hover,input[type=checkbox].form-check-input.invalid:hover,input[type=radio].form-check-input.invalid:hover,.form-check.hover .form-check-input.invalid,.form-check.hover input[type=checkbox].form-check-input.invalid,.form-check.hover input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.form-check-input.invalid:active,input[type=checkbox].form-check-input.invalid:active,input[type=radio].form-check-input.invalid:active,.form-check.active .form-check-input.invalid,.form-check.active input[type=checkbox].form-check-input.invalid,.form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.form-check-input.invalid:checked,input[type=checkbox].form-check-input.invalid:checked,input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.form-check-input.invalid:checked:hover,input[type=checkbox].form-check-input.invalid:checked:hover,input[type=radio].form-check-input.invalid:checked:hover,.form-check.hover .form-check-input.invalid:checked,.form-check.hover input[type=checkbox].form-check-input.invalid:checked,.form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.form-check-input.invalid:checked:active,input[type=checkbox].form-check-input.invalid:checked:active,input[type=radio].form-check-input.invalid:checked:active,.form-check.active .form-check-input.invalid:checked,.form-check.active input[type=checkbox].form-check-input.invalid:checked,.form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.form-check-input.invalid[disabled]:hover,input[type=checkbox].form-check-input.invalid[disabled]:hover,input[type=radio].form-check-input.invalid[disabled]:hover,.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.disabled .form-check-input.invalid:hover,.form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.form-check.disabled input[type=radio].form-check-input.invalid:hover,.form-check-input.invalid[disabled]:active,input[type=checkbox].form-check-input.invalid[disabled]:active,input[type=radio].form-check-input.invalid[disabled]:active,.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=radio].form-check-input.invalid:indeterminate:active,.form-check.disabled .form-check-input.invalid:active,.form-check.disabled input[type=checkbox].form-check-input.invalid:active,.form-check.disabled input[type=radio].form-check-input.invalid:active {background: #fff7f7;border-color: #d94141;cursor: default;}.form-check-input.invalid[disabled]:checked,input[type=checkbox].form-check-input.invalid[disabled]:checked,input[type=radio].form-check-input.invalid[disabled]:checked,.form-check-input.invalid:indeterminate:checked,input[type=checkbox].form-check-input.invalid:indeterminate:checked,input[type=radio].form-check-input.invalid:indeterminate:checked,.form-check.disabled .form-check-input.invalid:checked,.form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid,.theme-inverse input[type=checkbox].form-check-input.invalid,.theme-inverse input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.theme-inverse .form-check-input.invalid:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:hover,.theme-inverse input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check.hover .form-check-input.invalid,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.theme-inverse .form-check-input.invalid:active,.theme-inverse input[type=checkbox].form-check-input.invalid:active,.theme-inverse input[type=radio].form-check-input.invalid:active,.theme-inverse .form-check.active .form-check-input.invalid,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.theme-inverse .form-check-input.invalid:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:checked,.theme-inverse input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid:checked:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:hover,.theme-inverse input[type=radio].form-check-input.invalid:checked:hover,.theme-inverse .form-check.hover .form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.theme-inverse .form-check-input.invalid:checked:active,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:active,.theme-inverse input[type=radio].form-check-input.invalid:checked:active,.theme-inverse .form-check.active .form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.theme-inverse .form-check-input.invalid[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:hover,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:hover,.theme-inverse .form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check-input.invalid[disabled]:active,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:active,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:active,.theme-inverse .form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:active {background: #ffe6e6;border-color: #d94141;cursor: default;}.theme-inverse .form-check-input.invalid[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:checked,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:checked,.theme-inverse .form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}input[type=radio].form-check-input {border-radius: 8px;}input[type=radio].form-check-input:checked::after {background-color: #fff;border-radius: 3px;content: "";height: 6px;left: 5px;position: absolute;top: 5px;width: 6px;}input[type=checkbox].form-check-input {border-radius: 3px;}input[type=checkbox].form-check-input:indeterminate::after {border-bottom: 2px solid #fff;content: "";height: 4px;left: 26%;position: absolute;top: 20%;width: 7px;}input[type=checkbox].form-check-input:checked::after {border-bottom: 2px solid #fff;border-left: 2px solid #fff;content: "";height: 4px;left: 22%;position: absolute;top: 20%;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);width: 7px;}.form-check-inline {display: inline-block;}.form-check-inline + .form-check-inline {margin-left: 24px;margin-top: 0;}.col-form-label {font-size: 16px;line-height: 24px;margin-bottom: 0;padding-top: 8px;}.col-form-label-lg {font-size: 32px;line-height: 40px;padding-top: 4px;}.col-form-label-sm {font-size: 14px;line-height: 21px;padding-top: 5.5px;}.form-text {color: #555659;display: block;font-size: 14px;line-height: 21px;margin-top: 8px;}.form-text.invalid {color: #d94141;}.theme-inverse .form-text {color: #b1b1b3;}.theme-inverse .form-text.invalid {color: #f99;}.form-required::after {color: #d94141;content: "*";font-weight: normal;margin-left: 0.2em;}.chip.default-multi-select-input,.chip.small-multi-select-input {float: left;}.chip.default-multi-select-input {margin: 0.5px 4px 2px;}.chip.small-multi-select-input {margin: -1px 4px 1px;}.form-input-overlay {position: relative;}.form-input-overlay .overlay-front {left: 16px;position: absolute;top: 8px;}.form-input-overlay .overlay-front.overlay-sm {top: 4px;}.form-input-overlay .overlay-front.overlay-lg {top: 12px;}.form-input-overlay .overlay-back {position: absolute;right: 16px;top: 8px;}.form-input-overlay .overlay-back.overlay-sm {top: 4px;}.form-input-overlay .overlay-back.overlay-lg {top: 12px;}.form-input-overlay .form-control ~ .overlay-front,.form-input-overlay .form-control ~ .overlay-back {background-color: transparent;color: #222326;font-size: 16px;}.form-input-overlay .form-control:hover ~ .overlay-front,.form-input-overlay .form-control.hover ~ .overlay-front,.form-input-overlay .form-control:hover ~ .overlay-back,.form-input-overlay .form-control.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control:focus ~ .overlay-front,.form-input-overlay .form-control.focus ~ .overlay-front,.form-input-overlay .form-control:focus ~ .overlay-back,.form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control[disabled] ~ .overlay-front,.form-input-overlay .form-control.disabled ~ .overlay-front,.form-input-overlay .form-control[disabled] ~ .overlay-back,.form-input-overlay .form-control.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-input-overlay .form-control.form-control-transparent ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-inherit ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit ~ .overlay-back {color: inherit;font-size: inherit;font-weight: inherit;}.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .form-input-overlay .form-control ~ .overlay-front,.theme-inverse .form-input-overlay .form-control ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-back {color: #d7d7d9;}.form-input-overlay .form-control.form-control-outlined ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid ~ .overlay-front,.form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.hover ~ .overlay-front,.form-input-overlay .form-control.invalid:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:focus ~ .overlay-front,.form-input-overlay .form-control.invalid.focus ~ .overlay-front,.form-input-overlay .form-control.invalid:focus ~ .overlay-back,.form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .overlay-input-left-sm {padding-left: 32px;}.form-input-overlay .overlay-input-right-sm {padding-right: 32px;}.form-input-overlay .overlay-input-both-sm {padding-left: 32px;padding-right: 32px;}.form-input-overlay .overlay-input-left-md {padding-left: 56px;}.form-input-overlay .overlay-input-right-md {padding-right: 56px;}.form-input-overlay .overlay-input-both-md {padding-left: 56px;padding-right: 56px;}.form-input-overlay .overlay-input-left-lg {padding-left: 80px;}.form-input-overlay .overlay-input-right-lg {padding-right: 80px;}.form-input-overlay .overlay-input-both-lg {padding-left: 80px;padding-right: 80px;}.form-input-overlay .overlay-input-left-icon {padding-left: 40px;}.form-input-overlay .overlay-input-right-icon {padding-right: 40px;}.form-input-overlay .overlay-input-both-icon {padding-left: 40px;padding-right: 40px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl,.col,.col-auto,.col-grow,.col-1,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-10,.col-11,.col-12,.col-sm,.col-sm-auto,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-md,.col-md-auto,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-lg,.col-lg-auto,.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-xl,.col-xl-auto,.col-xl-1,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9,.col-xl-10,.col-xl-11,.col-xl-12 {min-height: 1px;padding-left: 8px;padding-right: 8px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl {margin-left: auto;margin-right: auto;width: 100%;}.container {max-width: 100%;}.container-sm {max-width: 100%;}.container-md {max-width: 100%;}.container-lg {max-width: 100%;}.container-xl {max-width: 100%;}.row {display: flex;flex-wrap: wrap;margin-left: -8px;margin-right: -8px;}.row.no-gutters {margin-left: 0;margin-right: 0;}.row.no-gutters > .col,.row.no-gutters > [class*="col-"] {padding-left: 0;padding-right: 0;}a.row {text-decoration: none;}.col {flex: 1 1 0%;min-width: 0;width: 100%;}.col-auto {flex: 0 0 auto;width: auto;}.col-grow {flex: 1 0 auto;}.col-icon {align-items: center;display: flex;flex: 0 0 24px;}.col-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-3 {flex: 0 0 25%;max-width: 25%;}.col-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-6 {flex: 0 0 50%;max-width: 50%;}.col-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-9 {flex: 0 0 75%;max-width: 75%;}.col-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-12 {flex: 0 0 100%;max-width: 100%;}.mo-identicon {background-color: #e3e4e6;border-radius: 3px;color: #555659;display: inline-block;font-size: 12px;height: 24px;line-height: 24px;overflow: hidden;position: relative;text-align: center;text-decoration: none;vertical-align: middle;width: 24px;}.mo-identicon img {height: 100%;width: 100%;}.mo-identicon-initials {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;color: #fff;height: 100%;text-shadow: 0 0 2px rgba(0,0,0,0.2);width: 100%;}.mo-identicon-placeholder {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;}.mo-identicon-placeholder .icon {color: #e3e4e6;height: 18px;width: 18px;}.mo-identicon-placeholder .icon,.momentum-body .mo-identicon-placeholder .icon {vertical-align: middle;}.mo-identicon-sm {font-size: 10px;height: 16px;line-height: 16px;width: 16px;}.mo-identicon-sm .mo-identicon-placeholder .icon {height: 12px;width: 12px;}.mo-identicon-lg {font-size: 14px;height: 32px;line-height: 32px;width: 32px;}.mo-identicon-lg .mo-identicon-placeholder .icon {height: 24px;width: 24px;}.mo-identicon-xl {font-size: 16px;height: 40px;line-height: 40px;width: 40px;}.mo-identicon-xl .mo-identicon-placeholder .icon {height: 30px;width: 30px;}.mo-identicon-initials-0 {background: -webkit-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -moz-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -o-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -ms-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: linear-gradient(-15deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;}.mo-identicon-initials-1 {background: -webkit-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -moz-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -o-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -ms-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: linear-gradient(-15deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;}.mo-identicon-initials-2 {background: -webkit-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -moz-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -o-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -ms-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: linear-gradient(-15deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;}.mo-identicon-initials-3 {background: -webkit-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -moz-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -o-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -ms-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: linear-gradient(-15deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;}.mo-identicon-initials-4 {background: -webkit-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -moz-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -o-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -ms-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: linear-gradient(-15deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;}.mo-identicon-initials-5 {background: -webkit-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -moz-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -o-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -ms-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: linear-gradient(-15deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;}.mo-identicon-initials-6 {background: -webkit-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -moz-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -o-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -ms-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: linear-gradient(-15deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;}.mo-identicon-initials-7 {background: -webkit-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -moz-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -o-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -ms-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: linear-gradient(-15deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;}.mo-identicon-initials-8 {background: -webkit-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -moz-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -o-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -ms-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: linear-gradient(-15deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;}.mo-identicon-initials-9 {background: -webkit-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -moz-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -o-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -ms-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: linear-gradient(-15deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;}.mo-identicon-initials-10 {background: -webkit-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -moz-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -o-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -ms-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: linear-gradient(-15deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;}.mo-identicon-initials-11 {background: -webkit-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -moz-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -o-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -ms-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: linear-gradient(-15deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;}.mo-identicon-initials-12 {background: -webkit-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -moz-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -o-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -ms-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: linear-gradient(-15deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;}.mo-identicon-initials-13 {background: -webkit-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -moz-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -o-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -ms-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: linear-gradient(-15deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;}.mo-identicon-initials-14 {background: -webkit-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -moz-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -o-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -ms-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: linear-gradient(-15deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;}.mo-identicon-initials-15 {background: -webkit-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -moz-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -o-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -ms-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: linear-gradient(-15deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;}.mo-identicon-initials-16 {background: -webkit-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -moz-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -o-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -ms-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: linear-gradient(-15deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;}.mo-identicon-initials-17 {background: -webkit-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -moz-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -o-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -ms-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: linear-gradient(-15deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;}.mo-identicon-initials-18 {background: -webkit-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -moz-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -o-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -ms-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: linear-gradient(-15deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;}.mo-identicon-initials-19 {background: -webkit-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -moz-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -o-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -ms-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: linear-gradient(-15deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;}.mo-identicon-initials-20 {background: -webkit-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -moz-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -o-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -ms-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: linear-gradient(-15deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;}.mo-identicon-initials-21 {background: -webkit-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -moz-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -o-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -ms-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: linear-gradient(-15deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;}.mo-identicon-initials-22 {background: -webkit-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -moz-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -o-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -ms-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: linear-gradient(-15deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;}.mo-identicon-initials-23 {background: -webkit-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -moz-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -o-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -ms-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: linear-gradient(-15deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;}.mo-identicon-initials-24 {background: -webkit-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -moz-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -o-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -ms-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: linear-gradient(-15deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;}.mo-identicon-initials-25 {background: -webkit-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -moz-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -o-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -ms-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: linear-gradient(-15deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;}.mo-identicon-initials-26 {background: -webkit-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -moz-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -o-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -ms-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: linear-gradient(-15deg, #515151, #515151 49%, #707070 51%, #707070) #515151;}.mo-identicon-initials-27 {background: -webkit-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -moz-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -o-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -ms-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: linear-gradient(-15deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;}.mo-identicon-initials-28 {background: -webkit-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -moz-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -o-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -ms-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: linear-gradient(-15deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;}.mo-identicon-initials-29 {background: -webkit-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -moz-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -o-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -ms-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: linear-gradient(-15deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;}.mo-identicon-initials-30 {background: -webkit-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -moz-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -o-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -ms-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: linear-gradient(-15deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;}.list-row {border-bottom: 1px solid #e3e4e6;border-top: 1px solid #e3e4e6;display: flex;flex-wrap: wrap;font-size: 16px;line-height: 24px;}.list-row + .list-row {margin-top: -1px;}.list-row > .col,.list-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.list-row.clickable:hover {background: #f0f1f2;cursor: pointer;}.list-row.clickable:active {background: #e3e4e6;}.list-row.clickable.selected {background: #f3faff;}.list-row.clickable.selected:hover {background: #e1f3ff;}.list-row.clickable.selected:active {background: #bfe5ff;}.list-row.hover,.list-row > .col.hover,.list-row > [class*="col-"].hover {background: #f0f1f2;}.list-row.active,.list-row > .col.active,.list-row > [class*="col-"].active {background: #e3e4e6;}.list-row.selected,.list-row > .col.selected,.list-row > [class*="col-"].selected {background: #f3faff;}.list-row.selected.hover,.list-row > .col.selected.hover,.list-row > [class*="col-"].selected.hover {background: #e1f3ff;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"] {text-decoration: none;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"],a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover,a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active,a.list-row:visited,.momentum-body a.list-row:visited,.list-row > a.col:visited,.list-row > a[class*="col-"]:visited,.momentum-body .momentum-body a.list-row:visited,.momentum-body .list-row > a.col:visited,.momentum-body .list-row > a[class*="col-"]:visited {color: #222326;}a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover {background: #f0f1f2;}a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active {background: #e3e4e6;}a.list-row.selected:active,.momentum-body a.list-row.selected:active,.list-row > a.col.selected:active,.list-row > a[class*="col-"].selected:active {background: #bfe5ff;}a.list-row.selected.selected:hover,.momentum-body a.list-row.selected.selected:hover,.list-row > a.col.selected.selected:hover,.list-row > a[class*="col-"].selected.selected:hover {background: #e1f3ff;}.list-row > .col-form-label {padding-top: 16px;}.list-row > .col-form-label-lg {padding-top: 12px;}.list-row > .col-form-label-sm {padding-top: 13.5px;}.list-row-head {border-top: 0;}.col-list-row-header {align-self: flex-end;color: #969799;font-size: 12px;line-height: 18px;}.menu-row {display: flex;flex-wrap: wrap;font-size: 14px;line-height: 21px;padding-left: 8px;padding-right: 8px;}.menu-row h3,.menu-row h4 {margin-bottom: 0;}.menu-row h3,.menu-row .momentum-body h3,.menu-row .text-h3,.menu-row .text-h3_5 {font-size: 20px;line-height: 24px;}.menu-row .font-size-h3 {font-size: 20px;}.menu-row .line-height-h3 {line-height: 24px;}.menu-row h4,.menu-row .momentum-body h4,.menu-row .text-h4 {font-size: 16px;line-height: 24px;}.menu-row .font-size-h4 {font-size: 16px;}.menu-row .line-height-h4 {line-height: 24px;}.menu-row > .col,.menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.menu-row.hover {background: #f0f1f2;}.menu-row.active {background: #e3e4e6;}.menu-row.selected {background: #e1f3ff;}.menu-row.selected.hover {background: #bfe5ff;}.menu-row.selected.active {background: #a6daff;}.menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.menu-row {text-decoration: none;}a.menu-row:hover,a.menu-row:active,a.menu-row:visited {color: inherit;}a.menu-row:hover {background: #f0f1f2;}a.menu-row:active {background: #e3e4e6;}a.menu-row.selected:hover {background: #bfe5ff;}a.menu-row.selected:active {background: #a6daff;}.menu-divider {border-top: 1px solid #e3e4e6;margin-bottom: 4px;margin-top: 3px;}.message {color: #222326;background-color: #f0f1f2;border-radius: 3px;padding-bottom: 8px;padding-left: 40px;padding-right: 32px;padding-top: 8px;position: relative;}.message > .icon {position: absolute;left: 16px;top: 11px;}.message > .icon path {fill: #969799;}.message > p,.momentum-body .message > p {margin-bottom: 0;}.message > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;line-height: 16px;height: 16px;position: absolute;right: 16px;text-align: center;top: 11px;width: 16px;}.message > .close:hover::after {color: #555659;}.message > .close:active::after {color: #222326;}.message > .message-buttons {clear: left;float: right;margin-top: -4px;margin-right: -16px;padding-left: 4px;}.message > .message-buttons > .button-link {margin-top: 4px;}.message.message-info {background-color: #e1f3ff;}.message.message-info > .icon path {fill: #0c92f3;}.message.message-warning {background-color: #fec;}.message.message-warning > .icon path {fill: #ff9000;}.message.message-positive {background-color: #d4f5c4;}.message.message-positive > .icon path {fill: #39bf71;}.message.message-negative {background-color: #ffe6e6;}.message.message-negative > .icon path {fill: #d94141;}.message.message-gray {background-color: #f0f1f2;}.message.message-blue {background-color: #e1f3ff;}.message.message-red {background-color: #ffe6e6;}.message.message-green {background-color: #d4f5c4;}.message.message-yellow {background-color: #fec;}.message.message-rose {background-color: #ffe0f0;}.message.message-violet {background-color: #f5e0ff;}.message.message-turquoise {background-color: #d9f7fa;}.message.message-striped-red {background: -webkit-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -moz-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -o-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -ms-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: repeating-linear-gradient(105deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);}.message.message-striped-blue {background: -webkit-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -moz-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -o-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -ms-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: repeating-linear-gradient(105deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);}.message.message-striped-green {background: -webkit-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -moz-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -o-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -ms-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: repeating-linear-gradient(105deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);}.message.message-inverse {background-color: #555659;color: #fff;}.message.message-inverse > .icon path {fill: #b1b1b3;}.message.message-inverse > .close::after {color: #969799;}.message.message-inverse > .close:hover::after {color: #b1b1b3;}.message.message-inverse > .close:active::after {color: #707173;}.message.message-compact {padding-top: 4px;padding-bottom: 4px;}.message.message-compact > .icon {top: 8.125px;}.message.message-compact > .close::after {top: 8.125px;}.message.message-compact > .message-buttons {margin-top: -5.5px;}.message.message-compact > .message-buttons > .button-link {margin-top: 5.5px;}.modal-backdrop {background-color: rgba(0,0,0,0.3);bottom: 0;display: none;left: 0;position: absolute;right: 0;top: 0;width: 100%;}.modal-backdrop.show {display: flex;}.modal {background: #fff;border-radius: 3px;display: flex;flex-direction: column;left: 0;margin: 0 auto;max-height: calc(100% - 96px);max-width: 640px;min-width: 480px;position: absolute;right: 0;top: 80px;}.modal-content {display: flex;flex-direction: column;height: 100%;overflow: auto;padding: 0 32px;}.modal-content.no-padding {padding: 0;}.modal-actions {align-items: flex-end;display: flex;flex: auto;justify-content: flex-end;padding: 24px 32px;}.modal-actions-distributed {align-items: flex-end;display: flex;flex: auto;justify-content: space-between;padding: 32px 32px;}.modal-navigation {height: auto;padding: 24px 32px 24px 32px;position: relative;}.modal-navigation.no-padding {padding: 0;}.modal-close {color: #555659;position: absolute;right: 16px;top: 16px;}.nav-link,.momentum-body .nav-link {color: $navLinkColor;font-size: $navLinkFontSize;text-decoration: none;}.nav-link:hover,.momentum-body .nav-link:hover {color: $navLinkHoverColor;text-decoration: underline;}.nav-link:active,.momentum-body .nav-link:active {color: $navLinkActiveColor;text-decoration: underline;}.nav-link > .icon {margin-left: 4px;margin-right: 4px;}.nav-link > .icon:first-child {margin-left: 0;}.nav-link > .icon:last-child {margin-right: 0;}.progress-bar .bar,.progress-bar .bar-interactive {align-items: center;border-radius: 3px;display: flex;height: 16px;justify-content: center;-webkit-transition: width 350ms ease-out;-moz-transition: width 350ms ease-out;-o-transition: width 350ms ease-out;-ms-transition: width 350ms ease-out;transition: width 350ms ease-out;}.progress-bar {align-items: center;border-radius: 3px;display: flex;}.progress-bar .bar-container {align-content: center;align-items: center;display: flex;padding: 0;width: 100%;justify-content: space-between;position: relative;}.progress-bar .bar-interactive:hover {cursor: pointer;}.progress-bar .bar-progress-text {display: flex;font-size: 12px;line-height: 12px;position: absolute;padding: 0 0 0 4px;}.progress-bar .bar-progress-text-inverted {position: static;}.progress-bar .bar-title {margin-right: 8px;text-transform: capitalize;}.score {background-color: #555659;border-radius: 3px;color: #fff;display: inline-block;font-size: 16px;height: 24px;line-height: 24px;overflow: hidden;text-align: center;vertical-align: middle;width: 24px;}.score .icon {height: 16px;width: 16px;}.score .mo-identicon {border-radius: 0;vertical-align: unset;}.score.score-worst {background-color: #555659;color: #d7d7d9;}.score.score-bad {background-color: #555659;color: #b1b1b3;}.score.score-good {background-color: #555659;color: #61d086;}.score.score-best {background-color: #555659;color: #8ae58a;}.score.score-unknown {background-color: #e3e4e6;color: #555659;}.score.score-sm {font-size: 12px;height: 16px;line-height: 16px;width: 16px;}.score.score-sm .icon {height: 12px;width: 12px;}.score.score-lg {font-size: 20px;height: 32px;line-height: 32px;width: 32px;}.score.score-lg .icon {height: 20px;width: 20px;}.score.score-xl {font-size: 24px;height: 40px;line-height: 40px;width: 40px;}.score.score-xl .icon {height: 24px;width: 24px;}.score-group {display: inline-block;}.score-group .score {border-radius: 0;}.score-group .score:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.score-group .score:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.arrow {position: relative;}.arrow .line,.arrow .line::after {height: 40px;}.arrow .line {display: block;text-align: center;}.arrow .line::after {position: absolute;background: #b1b1b3;content: ' ';margin-left: -1px;width: 2px;}.arrow .arrow-overlay {position: absolute;top: 50%;left: 50%;-webkit-transform: translate(-50%, -50%);-moz-transform: translate(-50%, -50%);-o-transform: translate(-50%, -50%);-ms-transform: translate(-50%, -50%);transform: translate(-50%, -50%);}.arrow.direction-down .arrow-head,.arrow.direction-up .arrow-head {width: 10px;height: 10px;position: absolute;left: calc(50% - 5px);}.arrow.direction-down .arrow-head::after,.arrow.direction-up .arrow-head::after {display: block;position: absolute;content: '';height: 10px;margin: 0;padding: 0;width: 10px;-webkit-box-shadow: inset -2px 2px 0 0 #b1b1b3;box-shadow: inset -2px 2px 0 0 #b1b1b3;}.arrow.direction-up .arrow-head {top: 0;}.arrow.direction-up .arrow-head::after {-moz-transform: rotate(-45deg);-ms-transform: rotate(-45deg);-o-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.arrow.direction-down .arrow-head {bottom: 0;}.arrow.direction-down .arrow-head::after {-moz-transform: rotate(135deg);-ms-transform: rotate(135deg);-o-transform: rotate(135deg);-webkit-transform: rotate(135deg);-webkit-transform: rotate(135deg);-moz-transform: rotate(135deg);-o-transform: rotate(135deg);-ms-transform: rotate(135deg);transform: rotate(135deg);}.arrow.length-long .line,.arrow.length-long .line::after {height: 72px;}.animation-shimmer {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -moz-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -o-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -ms-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: linear-gradient(to right, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-size: 1000px 100%;}.animation-shimmer-inverse {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -moz-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -o-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -ms-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: linear-gradient(to right, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-size: 1000px 100%;}@-moz-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-webkit-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-o-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}.sidebar-menu {background-color: #f9f9f9;height: 100%;overflow-y: auto;width: 304px;}.sidebar-menu-width {width: 304px;}.sidebar-menu-row {color: #969799;display: flex;flex-wrap: wrap;padding-left: 16px;padding-right: 16px;}.sidebar-menu-row h4,.sidebar-menu-row h3 {margin-bottom: 0;}.sidebar-menu-row > .col,.sidebar-menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.sidebar-menu-row.hover {background: #fff;}.sidebar-menu-row.active {background: #e1f3ff;}.sidebar-menu-row.selected {color: #555659;background: #fff;border-left: 4px solid #0c92f3;padding-left: 12px;}.sidebar-menu-row.selected.hover {background: #f3faff;}.sidebar-menu-row.selected.active {background: #e1f3ff;}.sidebar-menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.sidebar-menu-row {color: #969799;text-decoration: none;}a.sidebar-menu-row:hover,a.sidebar-menu-row:active,a.sidebar-menu-row:visited {color: inherit;}a.sidebar-menu-row:hover {background: #fff;}a.sidebar-menu-row.selected {color: #555659;}a.sidebar-menu-row.selected:hover {background: #f3faff;}a.sidebar-menu-row.selected:active {background: #e1f3ff;}.sidebar-button-menu {width: 64px;height: 100%;overflow-y: auto;background-color: #f9f9f9;display: flex;flex-direction: column;align-items: center;}.sidebar-button-menu .sidebar-button-menu-row {margin-bottom: 8px;}.sidebar-button-menu .sidebar-button-menu-row .button {border: none;background-color: unset;background-image: unset;}.sidebar-button-menu .sidebar-button-menu-row:hover {margin-bottom: 6px;}.sidebar-button-menu .sidebar-button-menu-row:hover .button {-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);border-bottom: 2px solid #0c92f3;}.sidebar-button-menu .sidebar-button-menu-row.selected .button {background-color: #fff;-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);}.tab-links,.tab-links-border-bottom {display: flex;}.tab-link {border-bottom: 4px solid transparent;color: #969799;cursor: pointer;margin-left: 8px;margin-right: 8px;padding-bottom: 8px;}.tab-link:first-child {margin-left: 0;}.tab-link:last-child {margin-right: 0;}.tab-link,.momentum-body a.tab-link {text-decoration: none;color: #969799;}.tab-link:hover,.momentum-body a.tab-link:hover,.tab-link.hover,.momentum-body a.tab-link.hover {color: #707173;border-bottom-color: #b1b1b3;}.tab-link:active,.momentum-body a.tab-link:active {border-bottom-color: #969799;}.tab-link.selected,.momentum-body a.tab-link.selected {border-bottom-color: #0c92f3;color: #555659;}.tab-links-border-bottom {border-bottom: 1px solid #e3e4e6;}.tab-links-border-bottom .tab-link {margin-bottom: -1px;margin-left: 0;margin-right: 0;padding-left: 8px;padding-right: 8px;}.tabs {border-bottom: 1px solid #e3e4e6;display: flex;}.tab {border-color: #e3e4e6;border-style: solid;border-top-left-radius: 3px;border-top-right-radius: 3px;border-width: 1px;cursor: pointer;margin-bottom: -1px;margin-left: 8px;margin-right: 8px;padding: 8px 16px;text-align: center;}.tab:first-child {margin-left: 0;}.tab:last-child {margin-right: 0;}.tab,.momentum-body a.tab {background-color: #fff;color: #969799;text-decoration: none;}.tab:hover,.momentum-body a.tab:hover,.tab.hover,.momentum-body a.tab.hover {color: #707173;}.tab.selected,.momentum-body a.tab.selected {border-bottom-color: #fff;color: #555659;}.toast {-webkit-animation: toastFadeIn 0.3s ease-out;-moz-animation: toastFadeIn 0.3s ease-out;-o-animation: toastFadeIn 0.3s ease-out;-ms-animation: toastFadeIn 0.3s ease-out;animation: toastFadeIn 0.3s ease-out;border-left: 4px solid #969799;border-radius: 3px;display: inline-block;max-width: 480px;padding-bottom: 8px;padding-left: 48px;padding-right: 48px;padding-top: 8px;position: relative;}.toast > .icon {color: #555659;left: 16px;position: absolute;top: 12px;}.toast > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;height: 16px;line-height: 16px;position: absolute;right: 16px;text-align: center;top: 12px;width: 16px;}.toast > .close:hover::after {color: #555659;}.toast > .close:active::after {color: #222326;}.toast > .toast-buttons {margin-bottom: 8px;margin-top: 16px;}.toast.toast-info {border-left-color: #0c92f3;}.toast.toast-warning {border-left-color: #ffa60d;}.toast.toast-positive {border-left-color: #39bf71;}.toast.toast-negative {border-left-color: #d94141;}.toast.theme-inverse > .icon {color: #969799;}.toast.theme-inverse > .close::after {color: #969799;}.toast.theme-inverse > .close:hover::after {color: #b1b1b3;}.toast.theme-inverse > .close:active::after {color: #707173;}@-moz-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-webkit-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-o-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}.toggle {color: rgba(85,86,89,0.7);background-color: rgba(177,177,179,0.4);border-radius: 11px;border-width: 0;cursor: pointer;display: inline-block;height: 22px;margin: 1px 8px;padding: 0;position: relative;-webkit-transition: background-color 0.15s ease-in;-moz-transition: background-color 0.15s ease-in;-o-transition: background-color 0.15s ease-in;-ms-transition: background-color 0.15s ease-in;transition: background-color 0.15s ease-in;vertical-align: top;width: 40px;}.toggle:hover,.toggle.hover {background-color: rgba(177,177,179,0.6);}.toggle:active,.toggle.active {background-color: #b1b1b3;}.toggle:focus,.toggle.focus {outline: none;}.toggle[disabled],.toggle.disabled {background-color: rgba(177,177,179,0.4);}.toggle:first-child {margin-left: 0;}.toggle:last-child {margin-right: 0;}.toggle::after {background-color: #fff;border-radius: 8px;content: " ";display: block;height: 16px;left: 3px;top: 3px;position: absolute;-webkit-transition: left 0.15s linear;-moz-transition: left 0.15s linear;-o-transition: left 0.15s linear;-ms-transition: left 0.15s linear;transition: left 0.15s linear;width: 16px;}.toggle .icon,.momentum-body .toggle .icon {position: absolute;height: 12px;width: 12px;left: 23px;top: 5px;}.toggle.selected {color: rgba(255,255,255,0.7);background-color: #0c92f3;}.toggle.selected:hover,.toggle.selected.hover {background-color: #007fd9;}.toggle.selected:active,.toggle.selected.active {background-color: #0068b3;}.toggle.selected:focus,.toggle.selected.focus {outline: none;}.toggle.selected[disabled],.toggle.selected.disabled {background-color: #0c92f3;}.toggle.selected::after {left: 21px;}.toggle.selected .icon,.momentum-body .toggle.selected .icon {left: 5px;}.toggle.disabled {cursor: default;pointer-events: none;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.toggle.toggle-yellow.selected {color: rgba(255,255,255,0.7);background-color: #fb3;}.toggle.toggle-yellow.selected:hover,.toggle.toggle-yellow.selected.hover {background-color: #ffa60d;}.toggle.toggle-yellow.selected:active,.toggle.toggle-yellow.selected.active {background-color: #ff9000;}.toggle.toggle-yellow.selected:focus,.toggle.toggle-yellow.selected.focus {outline: none;}.toggle.toggle-yellow.selected[disabled],.toggle.toggle-yellow.selected.disabled {background-color: #fb3;}.toggle-lg {border-radius: 14px;height: 28px;width: 48px;margin-top: 4px;margin-bottom: 4px;}.toggle-lg::after {border-radius: 10px;height: 20px;left: 4px;top: 4px;width: 20px;}.toggle-lg .icon,.momentum-body .toggle-lg .icon {height: 16px;width: 16px;left: 26px;top: 6px;}.toggle-lg.selected::after {left: 24px;}.toggle-lg.selected .icon,.momentum-body .toggle-lg.selected .icon {left: 6px;}.toggle-sm {border-radius: 8px;height: 16px;width: 32px;margin-top: 2.5px;margin-bottom: 2.5px;}.toggle-sm::after {border-radius: 6px;height: 12px;left: 2px;top: 2px;width: 12px;}.toggle-sm .icon,.momentum-body .toggle-sm .icon {height: 9px;width: 9px;left: 19.5px;top: 3.5px;}.toggle-sm.selected::after {left: 18px;}.toggle-sm.selected .icon,.momentum-body .toggle-sm.selected .icon {left: 3.5px;}.text-h1 {font-size: 40px;font-weight: bold;line-height: 48px;}.text-h2 {font-size: 32px;font-weight: bold;line-height: 40px;}.text-h3 {font-size: 24px;font-weight: bold;line-height: 36px;}.text-h3_5 {font-size: 20px;font-weight: bold;line-height: 24px;}.text-h4 {font-size: 16px;font-weight: bold;line-height: 24px;}.text-h5 {font-size: 14px;font-weight: bold;line-height: 21px;}.text-base {font-size: 16px;font-weight: normal;line-height: 24px;}.text-small {font-size: 14px;font-weight: normal;line-height: 21px;}.text-caption {font-size: 12px;font-weight: normal;line-height: 18px;}.font-size-h1 {font-size: 40px;}.font-size-h2 {font-size: 32px;}.font-size-h3 {font-size: 24px;}.font-size-h3_5 {font-size: 20px;}.font-size-h4 {font-size: 16px;}.font-size-base {font-size: 16px;}.font-size-small {font-size: 14px;}.font-size-caption {font-size: 12px;}.line-height-h1 {line-height: 48px;}.line-height-h2 {line-height: 40px;}.line-height-h3 {line-height: 36px;}.line-height-h3_5 {line-height: 24px;}.line-height-h4 {line-height: 24px;}.line-height-base {line-height: 24px;}.line-height-small {line-height: 21px;}.line-height-caption {line-height: 18px;}.text-color-heading {color: #222326;}.text-color-body {color: #222326;}.text-muted {color: #555659;}.text-positive {color: #19a654;}.text-muted-positive {color: #61d086;}.text-negative {color: #d94141;}.text-muted-negative {color: #f99;}.upload {align-items: center;background-color: #fff;border: 2px #d7d7d9;border-style: dashed;color: #969799;cursor: pointer;display: flex;flex-direction: column;justify-content: center;padding: 8px;position: relative;}.upload:hover,.upload.hover {background-color: #f3faff;}.upload .upload-file {cursor: pointer;height: 100%;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);position: absolute;width: 100%;}.upload > .remove::after {align-items: center;background-color: #555659;border-radius: 50%;color: #fff;content: "✕";display: flex;font-size: 12px;height: 18px;justify-content: center;line-height: 12px;position: absolute;right: 12px;top: 12px;width: 18px;}.upload > .remove:hover::after {background-color: #707173;}.upload > .remove:active::after {background-color: #3b3d3f;}.upload-dragging {background-color: #f3faff;}.upload-no-border {border: 0;}.upload-dropping {background-color: #f3faff;border: 2px #0c92f3;border-style: dashed;}.upload-error {border: 2px #d94141;border-style: dashed;}.upload-preview {display: inline-block;line-height: 0;padding: 0;}.upload-icon {color: #d7d7d9;}.upload-icon.icon {margin-left: 0;margin-right: 0;}.animation-rotate-infinite {-webkit-animation: rotate-infinite infinite;-moz-animation: rotate-infinite infinite;-o-animation: rotate-infinite infinite;-ms-animation: rotate-infinite infinite;animation: rotate-infinite infinite;}.animation-fade-in {-webkit-animation: fade-in 1 ease both;-moz-animation: fade-in 1 ease both;-o-animation: fade-in 1 ease both;-ms-animation: fade-in 1 ease both;animation: fade-in 1 ease both;}.animation-fade-out {-webkit-animation: fade-out 1 ease both;-moz-animation: fade-out 1 ease both;-o-animation: fade-out 1 ease both;-ms-animation: fade-out 1 ease both;animation: fade-out 1 ease both;}.animation-ease {-webkit-animation-timing-function: ease;-moz-animation-timing-function: ease;-o-animation-timing-function: ease;-ms-animation-timing-function: ease;animation-timing-function: ease;}.animation-linear {-webkit-animation-timing-function: linear;-moz-animation-timing-function: linear;-o-animation-timing-function: linear;-ms-animation-timing-function: linear;animation-timing-function: linear;}.animation-duration-100ms {-webkit-animation-duration: 100ms;-moz-animation-duration: 100ms;-o-animation-duration: 100ms;-ms-animation-duration: 100ms;animation-duration: 100ms;}.animation-duration-200ms {-webkit-animation-duration: 200ms;-moz-animation-duration: 200ms;-o-animation-duration: 200ms;-ms-animation-duration: 200ms;animation-duration: 200ms;}.animation-duration-300ms {-webkit-animation-duration: 300ms;-moz-animation-duration: 300ms;-o-animation-duration: 300ms;-ms-animation-duration: 300ms;animation-duration: 300ms;}.animation-duration-400ms {-webkit-animation-duration: 400ms;-moz-animation-duration: 400ms;-o-animation-duration: 400ms;-ms-animation-duration: 400ms;animation-duration: 400ms;}.animation-duration-500ms {-webkit-animation-duration: 500ms;-moz-animation-duration: 500ms;-o-animation-duration: 500ms;-ms-animation-duration: 500ms;animation-duration: 500ms;}.animation-duration-1000ms {-webkit-animation-duration: 1000ms;-moz-animation-duration: 1000ms;-o-animation-duration: 1000ms;-ms-animation-duration: 1000ms;animation-duration: 1000ms;}.animation-duration-2000ms {-webkit-animation-duration: 2000ms;-moz-animation-duration: 2000ms;-o-animation-duration: 2000ms;-ms-animation-duration: 2000ms;animation-duration: 2000ms;}.animation-count-1 {-webkit-animation-iteration-count: 1;-moz-animation-iteration-count: 1;-o-animation-iteration-count: 1;-ms-animation-iteration-count: 1;animation-iteration-count: 1;}.animation-count-infinite {-webkit-animation-iteration-count: infinite;-moz-animation-iteration-count: infinite;-o-animation-iteration-count: infinite;-ms-animation-iteration-count: infinite;animation-iteration-count: infinite;}.animation-direction-normal {-webkit-animation-direction: normal;-moz-animation-direction: normal;-o-animation-direction: normal;-ms-animation-direction: normal;animation-direction: normal;}.animation-direction-reverse {-webkit-animation-direction: reverse;-moz-animation-direction: reverse;-o-animation-direction: reverse;-ms-animation-direction: reverse;animation-direction: reverse;}@-moz-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-moz-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}.border {border: 1px solid #e3e4e6;}.border-top {border-top: 1px solid #e3e4e6;}.border-right {border-right: 1px solid #e3e4e6;}.border-bottom {border-bottom: 1px solid #e3e4e6;}.border-left {border-left: 1px solid #e3e4e6;}.border-width-1 {border-width: 4px;}.border-width-2 {border-width: 8px;}.border-width-3 {border-width: 12px;}.border-width-4 {border-width: 16px;}.border-width-5 {border-width: 20px;}.border-width-6 {border-width: 24px;}.border-width-7 {border-width: 28px;}.border-width-8 {border-width: 32px;}.border-width-9 {border-width: 36px;}.border-width-10 {border-width: 40px;}.border-width-11 {border-width: 44px;}.border-width-12 {border-width: 48px;}.border-width-13 {border-width: 52px;}.border-width-14 {border-width: 56px;}.border-width-15 {border-width: 60px;}.border-width-16 {border-width: 64px;}.border-width-17 {border-width: 68px;}.border-width-18 {border-width: 72px;}.border-width-19 {border-width: 76px;}.border-width-20 {border-width: 80px;}.border-width-21 {border-width: 84px;}.border-width-22 {border-width: 88px;}.border-width-23 {border-width: 92px;}.border-width-24 {border-width: 96px;}.border-width-25 {border-width: 100px;}.border-width-26 {border-width: 104px;}.border-width-27 {border-width: 108px;}.border-width-28 {border-width: 112px;}.border-width-29 {border-width: 116px;}.border-width-30 {border-width: 120px;}.border-none {border: 0;}.border-top-none {border-top: 0;}.border-right-none {border-right: 0;}.border-bottom-none {border-bottom: 0;}.border-left-none {border-left: 0;}.rounded {border-radius: 3px;}.circle {border-radius: 50%;}.rounded-top {border-radius: 3px 3px 0 0;}.rounded-right {border-radius: 0 3px 3px 0;}.rounded-bottom {border-radius: 0 0 3px 3px;}.rounded-left {border-radius: 3px 0 0 3px;}.not-rounded {border-radius: 0;}.dashed {border-style: dashed;}.text-white {color: #fff;}.bg-white {background-color: #fff;}.border-white {border-color: #fff;}.text-black {color: #000;}.bg-black {background-color: #000;}.border-black {border-color: #000;}.text-ghost {color: #f4f7fa;}.bg-ghost {background-color: #f4f7fa;}.border-ghost {border-color: #f4f7fa;}.text-gray {color: #969799;}.bg-gray {background-color: #969799;}.border-gray {border-color: #969799;}.text-blue {color: #0c92f3;}.bg-blue {background-color: #0c92f3;}.border-blue {border-color: #0c92f3;}.text-red {color: #d94141;}.bg-red {background-color: #d94141;}.border-red {border-color: #d94141;}.text-green {color: #39bf71;}.bg-green {background-color: #39bf71;}.border-green {border-color: #39bf71;}.text-yellow {color: #ffa60d;}.bg-yellow {background-color: #ffa60d;}.border-yellow {border-color: #ffa60d;}.text-rose {color: #dc4c7d;}.bg-rose {background-color: #dc4c7d;}.border-rose {border-color: #dc4c7d;}.text-violet {color: #a452cc;}.bg-violet {background-color: #a452cc;}.border-violet {border-color: #a452cc;}.text-turquoise {color: #1cadba;}.bg-turquoise {background-color: #1cadba;}.border-turquoise {border-color: #1cadba;}.text-gray-50 {color: #f9f9f9;}.bg-gray-50 {background-color: #f9f9f9;}.border-gray-50 {border-color: #f9f9f9;}.text-gray-100 {color: #f0f1f2;}.bg-gray-100 {background-color: #f0f1f2;}.border-gray-100 {border-color: #f0f1f2;}.text-gray-200 {color: #e3e4e6;}.bg-gray-200 {background-color: #e3e4e6;}.border-gray-200 {border-color: #e3e4e6;}.text-gray-300 {color: #d7d7d9;}.bg-gray-300 {background-color: #d7d7d9;}.border-gray-300 {border-color: #d7d7d9;}.text-gray-400 {color: #b1b1b3;}.bg-gray-400 {background-color: #b1b1b3;}.border-gray-400 {border-color: #b1b1b3;}.text-gray-500 {color: #969799;}.bg-gray-500 {background-color: #969799;}.border-gray-500 {border-color: #969799;}.text-gray-600 {color: #707173;}.bg-gray-600 {background-color: #707173;}.border-gray-600 {border-color: #707173;}.text-gray-700 {color: #555659;}.bg-gray-700 {background-color: #555659;}.border-gray-700 {border-color: #555659;}.text-gray-800 {color: #3b3d3f;}.bg-gray-800 {background-color: #3b3d3f;}.border-gray-800 {border-color: #3b3d3f;}.text-gray-900 {color: #222326;}.bg-gray-900 {background-color: #222326;}.border-gray-900 {border-color: #222326;}.text-blue-50 {color: #f3faff;}.bg-blue-50 {background-color: #f3faff;}.border-blue-50 {border-color: #f3faff;}.text-red-50 {color: #fff7f7;}.bg-red-50 {background-color: #fff7f7;}.border-red-50 {border-color: #fff7f7;}.text-green-50 {color: #e1fae5;}.bg-green-50 {background-color: #e1fae5;}.border-green-50 {border-color: #e1fae5;}.text-yellow-50 {color: #fff6e5;}.bg-yellow-50 {background-color: #fff6e5;}.border-yellow-50 {border-color: #fff6e5;}.text-blue-100 {color: #e1f3ff;}.bg-blue-100 {background-color: #e1f3ff;}.border-blue-100 {border-color: #e1f3ff;}.text-red-100 {color: #ffe6e6;}.bg-red-100 {background-color: #ffe6e6;}.border-red-100 {border-color: #ffe6e6;}.text-green-100 {color: #d4f5c4;}.bg-green-100 {background-color: #d4f5c4;}.border-green-100 {border-color: #d4f5c4;}.text-yellow-100 {color: #fec;}.bg-yellow-100 {background-color: #fec;}.border-yellow-100 {border-color: #fec;}.text-blue-200 {color: #bfe5ff;}.bg-blue-200 {background-color: #bfe5ff;}.border-blue-200 {border-color: #bfe5ff;}.text-red-200 {color: #ffbfbf;}.bg-red-200 {background-color: #ffbfbf;}.border-red-200 {border-color: #ffbfbf;}.text-green-200 {color: #b4f0a8;}.bg-green-200 {background-color: #b4f0a8;}.border-green-200 {border-color: #b4f0a8;}.text-yellow-200 {color: #ffe5b2;}.bg-yellow-200 {background-color: #ffe5b2;}.border-yellow-200 {border-color: #ffe5b2;}.text-blue-300 {color: #a6daff;}.bg-blue-300 {background-color: #a6daff;}.border-blue-300 {border-color: #a6daff;}.text-red-300 {color: #f99;}.bg-red-300 {background-color: #f99;}.border-red-300 {border-color: #f99;}.text-green-300 {color: #8ae58a;}.bg-green-300 {background-color: #8ae58a;}.border-green-300 {border-color: #8ae58a;}.text-yellow-300 {color: #ffdf88;}.bg-yellow-300 {background-color: #ffdf88;}.border-yellow-300 {border-color: #ffdf88;}.text-blue-400 {color: #4cb5ff;}.bg-blue-400 {background-color: #4cb5ff;}.border-blue-400 {border-color: #4cb5ff;}.text-red-400 {color: #f26161;}.bg-red-400 {background-color: #f26161;}.border-red-400 {border-color: #f26161;}.text-green-400 {color: #61d086;}.bg-green-400 {background-color: #61d086;}.border-green-400 {border-color: #61d086;}.text-yellow-400 {color: #fb3;}.bg-yellow-400 {background-color: #fb3;}.border-yellow-400 {border-color: #fb3;}.text-blue-500 {color: #0c92f3;}.bg-blue-500 {background-color: #0c92f3;}.border-blue-500 {border-color: #0c92f3;}.text-red-500 {color: #d94141;}.bg-red-500 {background-color: #d94141;}.border-red-500 {border-color: #d94141;}.text-green-500 {color: #39bf71;}.bg-green-500 {background-color: #39bf71;}.border-green-500 {border-color: #39bf71;}.text-yellow-500 {color: #ffa60d;}.bg-yellow-500 {background-color: #ffa60d;}.border-yellow-500 {border-color: #ffa60d;}.text-blue-600 {color: #007fd9;}.bg-blue-600 {background-color: #007fd9;}.border-blue-600 {border-color: #007fd9;}.text-red-600 {color: #bf3939;}.bg-red-600 {background-color: #bf3939;}.border-red-600 {border-color: #bf3939;}.text-green-600 {color: #19a654;}.bg-green-600 {background-color: #19a654;}.border-green-600 {border-color: #19a654;}.text-yellow-600 {color: #ff9000;}.bg-yellow-600 {background-color: #ff9000;}.border-yellow-600 {border-color: #ff9000;}.text-blue-700 {color: #0068b3;}.bg-blue-700 {background-color: #0068b3;}.border-blue-700 {border-color: #0068b3;}.text-red-700 {color: #a62929;}.bg-red-700 {background-color: #a62929;}.border-red-700 {border-color: #a62929;}.text-green-700 {color: #0e8c42;}.bg-green-700 {background-color: #0e8c42;}.border-green-700 {border-color: #0e8c42;}.text-yellow-700 {color: #e67600;}.bg-yellow-700 {background-color: #e67600;}.border-yellow-700 {border-color: #e67600;}.text-turquoise-50 {color: #f0fbfc;}.bg-turquoise-50 {background-color: #f0fbfc;}.border-turquoise-50 {border-color: #f0fbfc;}.text-turquoise-100 {color: #d9f7fa;}.bg-turquoise-100 {background-color: #d9f7fa;}.border-turquoise-100 {border-color: #d9f7fa;}.text-turquoise-200 {color: #b8f0f5;}.bg-turquoise-200 {background-color: #b8f0f5;}.border-turquoise-200 {border-color: #b8f0f5;}.text-turquoise-300 {color: #91eaf2;}.bg-turquoise-300 {background-color: #91eaf2;}.border-turquoise-300 {border-color: #91eaf2;}.text-turquoise-400 {color: #33c0cd;}.bg-turquoise-400 {background-color: #33c0cd;}.border-turquoise-400 {border-color: #33c0cd;}.text-turquoise-500 {color: #1cadba;}.bg-turquoise-500 {background-color: #1cadba;}.border-turquoise-500 {border-color: #1cadba;}.text-turquoise-600 {color: #0097a6;}.bg-turquoise-600 {background-color: #0097a6;}.border-turquoise-600 {border-color: #0097a6;}.text-turquoise-700 {color: #007580;}.bg-turquoise-700 {background-color: #007580;}.border-turquoise-700 {border-color: #007580;}.text-turquoise-800 {color: #005e66;}.bg-turquoise-800 {background-color: #005e66;}.border-turquoise-800 {border-color: #005e66;}.text-turquoise-900 {color: #00464d;}.bg-turquoise-900 {background-color: #00464d;}.border-turquoise-900 {border-color: #00464d;}.text-violet-50 {color: #f8ebff;}.bg-violet-50 {background-color: #f8ebff;}.border-violet-50 {border-color: #f8ebff;}.text-violet-100 {color: #f5e0ff;}.bg-violet-100 {background-color: #f5e0ff;}.border-violet-100 {border-color: #f5e0ff;}.text-violet-200 {color: #ebc4ff;}.bg-violet-200 {background-color: #ebc4ff;}.border-violet-200 {border-color: #ebc4ff;}.text-violet-300 {color: #dea2fc;}.bg-violet-300 {background-color: #dea2fc;}.border-violet-300 {border-color: #dea2fc;}.text-violet-400 {color: #bf75e3;}.bg-violet-400 {background-color: #bf75e3;}.border-violet-400 {border-color: #bf75e3;}.text-violet-500 {color: #a452cc;}.bg-violet-500 {background-color: #a452cc;}.border-violet-500 {border-color: #a452cc;}.text-violet-600 {color: #9c2bd4;}.bg-violet-600 {background-color: #9c2bd4;}.border-violet-600 {border-color: #9c2bd4;}.text-violet-700 {color: #801bb2;}.bg-violet-700 {background-color: #801bb2;}.border-violet-700 {border-color: #801bb2;}.text-violet-800 {color: #620e8c;}.bg-violet-800 {background-color: #620e8c;}.border-violet-800 {border-color: #620e8c;}.text-violet-900 {color: #521173;}.bg-violet-900 {background-color: #521173;}.border-violet-900 {border-color: #521173;}.bg-transparent {background: transparent;}.cursor-pointer {cursor: pointer;}.cursor-text {cursor: text;}.cursor-default {cursor: default;}.cursor-inherit {cursor: inherit;}.flex {display: flex;}.flex-column {flex-direction: column;}.flex-row {flex-direction: row;}.flex-row-reverse {flex-direction: row-reverse;}.flex-column-reverse {flex-direction: column-reverse;}.flex-wrap {flex-wrap: wrap;}.flex-nowrap {flex-wrap: nowrap;}.flex-grow {flex: 1 0 auto;}.flex-shrink {flex: 0 1 auto;}.flex-auto {flex: 1 1 auto;min-height: 0;min-width: 0;}.flex-none {flex: none;}.items-start {align-items: flex-start;}.items-end {align-items: flex-end;}.items-center {align-items: center;}.items-baseline {align-items: baseline;}.items-stretch {align-items: stretch;}.self-start {align-self: flex-start;}.self-end {align-self: flex-end;}.self-center {align-self: center;}.self-baseline {align-self: baseline;}.self-stretch {align-self: stretch;}.justify-start {justify-content: flex-start;}.justify-end {justify-content: flex-end;}.justify-center {justify-content: center;}.justify-between {justify-content: space-between;}.justify-around {justify-content: space-around;}.justify-evenly {justify-content: space-evenly;}.content-start {align-content: flex-start;}.content-end {align-content: flex-end;}.content-center {align-content: center;}.content-between {align-content: space-between;}.content-around {align-content: space-around;}.content-stretch {align-content: stretch;}.order-0 {order: 0;}.order-1 {order: 1;}.order-2 {order: 2;}.order-3 {order: 3;}.order-last {order: 99999;}.icon-size-base {height: 16px;width: 16px;}.icon-size-caption,.momentum-body .icon-size-caption {height: 12px;width: 12px;}.identicon-size,.momentum-body .identicon-size {height: 24px;width: 24px;line-height: 24px;}.display-none {display: none;}.display-inline,.inline {display: inline;}.display-block,.block {display: block;}.display-inline-block,.inline-block {display: inline-block;}.display-table,.table {display: table;}.display-table-cell,.table-cell {display: table-cell;}.visibility-hidden {visibility: hidden;}.overflow-hidden {overflow: hidden;}.overflow-scroll {overflow: scroll;}.overflow-auto {overflow: auto;}.overflow-visible {overflow: visible;}.float-left {float: left;}.float-right {float: right;}.fit-width {max-width: 100%;}.bulleted-list {margin-left: 16px;list-style-type: circle;}.bulleted-list li {margin-bottom: 8px;}.m0 {margin: 0;}.mt0 {margin-top: 0;}.mr0 {margin-right: 0;}.mb0 {margin-bottom: 0;}.ml0 {margin-left: 0;}.mx0 {margin-left: 0;margin-right: 0;}.my0 {margin-bottom: 0;margin-top: 0;}.m0_5 {margin: 4px;}.mt0_5 {margin-top: 4px;}.mr0_5 {margin-right: 4px;}.mb0_5 {margin-bottom: 4px;}.ml0_5 {margin-left: 4px;}.mx0_5 {margin-left: 4px;margin-right: 4px;}.my0_5 {margin-bottom: 4px;margin-top: 4px;}.m1 {margin: 8px;}.mt1 {margin-top: 8px;}.mr1 {margin-right: 8px;}.mb1 {margin-bottom: 8px;}.ml1 {margin-left: 8px;}.mx1 {margin-left: 8px;margin-right: 8px;}.my1 {margin-bottom: 8px;margin-top: 8px;}.m1_5 {margin: 12px;}.mt1_5 {margin-top: 12px;}.mr1_5 {margin-right: 12px;}.mb1_5 {margin-bottom: 12px;}.ml1_5 {margin-left: 12px;}.mx1_5 {margin-left: 12px;margin-right: 12px;}.my1_5 {margin-bottom: 12px;margin-top: 12px;}.m2 {margin: 16px;}.mt2 {margin-top: 16px;}.mr2 {margin-right: 16px;}.mb2 {margin-bottom: 16px;}.ml2 {margin-left: 16px;}.mx2 {margin-left: 16px;margin-right: 16px;}.my2 {margin-bottom: 16px;margin-top: 16px;}.m3 {margin: 24px;}.mt3 {margin-top: 24px;}.mr3 {margin-right: 24px;}.mb3 {margin-bottom: 24px;}.ml3 {margin-left: 24px;}.mx3 {margin-left: 24px;margin-right: 24px;}.my3 {margin-bottom: 24px;margin-top: 24px;}.m4 {margin: 32px;}.mt4 {margin-top: 32px;}.mr4 {margin-right: 32px;}.mb4 {margin-bottom: 32px;}.ml4 {margin-left: 32px;}.mx4 {margin-left: 32px;margin-right: 32px;}.my4 {margin-bottom: 32px;margin-top: 32px;}.m5 {margin: 40px;}.mt5 {margin-top: 40px;}.mr5 {margin-right: 40px;}.mb5 {margin-bottom: 40px;}.ml5 {margin-left: 40px;}.mx5 {margin-left: 40px;margin-right: 40px;}.my5 {margin-bottom: 40px;margin-top: 40px;}.m10 {margin: 80px;}.mt10 {margin-top: 80px;}.mr10 {margin-right: 80px;}.mb10 {margin-bottom: 80px;}.ml10 {margin-left: 80px;}.mx10 {margin-left: 80px;margin-right: 80px;}.my10 {margin-bottom: 80px;margin-top: 80px;}.mn1 {margin: -8px;}.mtn1 {margin-top: -8px;}.mrn1 {margin-right: -8px;}.mbn1 {margin-bottom: -8px;}.mln1 {margin-left: -8px;}.mxn1 {margin-left: -8px;margin-right: -8px;}.myn1 {margin-bottom: -8px;margin-top: -8px;}.mxn2 {margin-left: -16px;margin-right: -16px;}.mxn3 {margin-left: -24px;margin-right: -24px;}.mxn4 {margin-left: -32px;margin-right: -32px;}.mt-auto {margin-top: auto;}.mb-auto {margin-bottom: auto;}.my-auto {margin-top: auto;margin-bottom: auto;}.ml-auto {margin-left: auto;}.mr-auto {margin-right: auto;}.mx-auto {margin-left: auto;margin-right: auto;}.opacity-0 {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.opacity-0_1 {opacity: 0.1;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=10)";filter: alpha(opacity=10);}.opacity-0_2 {opacity: 0.2;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=20)";filter: alpha(opacity=20);}.opacity-0_3 {opacity: 0.3;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=30)";filter: alpha(opacity=30);}.opacity-0_4 {opacity: 0.4;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=40)";filter: alpha(opacity=40);}.opacity-0_5 {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.opacity-0_6 {opacity: 0.6;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=60)";filter: alpha(opacity=60);}.opacity-0_7 {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.opacity-0_8 {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.opacity-0_9 {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.opacity-1 {opacity: 1;-ms-filter: none;filter: none;}.outline-none {outline: 0;}.p0 {padding: 0;}.pt0 {padding-top: 0;}.pr0 {padding-right: 0;}.pb0 {padding-bottom: 0;}.pl0 {padding-left: 0;}.px0 {padding-left: 0;padding-right: 0;}.py0 {padding-bottom: 0;padding-top: 0;}.p0_5 {padding: 4px;}.pt0_5 {padding-top: 4px;}.pr0_5 {padding-right: 4px;}.pb0_5 {padding-bottom: 4px;}.pl0_5 {padding-left: 4px;}.px0_5 {padding-left: 4px;padding-right: 4px;}.py0_5 {padding-bottom: 4px;padding-top: 4px;}.p1 {padding: 8px;}.pt1 {padding-top: 8px;}.pr1 {padding-right: 8px;}.pb1 {padding-bottom: 8px;}.pl1 {padding-left: 8px;}.py1 {padding-bottom: 8px;padding-top: 8px;}.px1 {padding-left: 8px;padding-right: 8px;}.p1_5 {padding: 12px;}.pt1_5 {padding-top: 12px;}.pr1_5 {padding-right: 12px;}.pb1_5 {padding-bottom: 12px;}.pl1_5 {padding-left: 12px;}.px1_5 {padding-left: 12px;padding-right: 12px;}.py1_5 {padding-bottom: 12px;padding-top: 12px;}.p2 {padding: 16px;}.pt2 {padding-top: 16px;}.pr2 {padding-right: 16px;}.pb2 {padding-bottom: 16px;}.pl2 {padding-left: 16px;}.py2 {padding-bottom: 16px;padding-top: 16px;}.px2 {padding-left: 16px;padding-right: 16px;}.p3 {padding: 24px;}.pt3 {padding-top: 24px;}.pr3 {padding-right: 24px;}.pb3 {padding-bottom: 24px;}.pl3 {padding-left: 24px;}.py3 {padding-bottom: 24px;padding-top: 24px;}.px3 {padding-left: 24px;padding-right: 24px;}.p4 {padding: 32px;}.pt4 {padding-top: 32px;}.pr4 {padding-right: 32px;}.pb4 {padding-bottom: 32px;}.pl4 {padding-left: 32px;}.py4 {padding-bottom: 32px;padding-top: 32px;}.px4 {padding-left: 32px;padding-right: 32px;}.p5 {padding: 40px;}.pt5 {padding-top: 40px;}.pr5 {padding-right: 40px;}.pb5 {padding-bottom: 40px;}.pl5 {padding-left: 40px;}.py5 {padding-bottom: 40px;padding-top: 40px;}.px5 {padding-left: 40px;padding-right: 40px;}.p10 {padding: 80px;}.pt10 {padding-top: 80px;}.pr10 {padding-right: 80px;}.pb10 {padding-bottom: 80px;}.pl10 {padding-left: 80px;}.py10 {padding-bottom: 80px;padding-top: 80px;}.px10 {padding-left: 80px;padding-right: 80px;}.pointer-events-none {pointer-events: none;}.relative {position: relative;}.absolute {position: absolute;}.sticky {position: sticky;}.top-0 {top: 0;}.right-0 {right: 0;}.bottom-0 {bottom: 0;}.left-0 {left: 0;}.height-full {height: 100%;}.width-full {width: 100%;}.max-width-full {max-width: 100%;}.width-0 {width: 0;}.height-0 {height: 0;}.width-auto {width: auto;}.min-width-1 {min-width: 8px;}.min-height-1 {min-height: 8px;}.max-width-1 {max-width: 8px;}.max-height-1 {max-height: 8px;}.min-width-2 {min-width: 16px;}.min-height-2 {min-height: 16px;}.max-width-2 {max-width: 16px;}.max-height-2 {max-height: 16px;}.min-width-3 {min-width: 24px;}.min-height-3 {min-height: 24px;}.max-width-3 {max-width: 24px;}.max-height-3 {max-height: 24px;}.min-width-4 {min-width: 32px;}.min-height-4 {min-height: 32px;}.max-width-4 {max-width: 32px;}.max-height-4 {max-height: 32px;}.min-width-5 {min-width: 40px;}.min-height-5 {min-height: 40px;}.max-width-5 {max-width: 40px;}.max-height-5 {max-height: 40px;}.min-width-6 {min-width: 48px;}.min-height-6 {min-height: 48px;}.max-width-6 {max-width: 48px;}.max-height-6 {max-height: 48px;}.min-width-7 {min-width: 56px;}.min-height-7 {min-height: 56px;}.max-width-7 {max-width: 56px;}.max-height-7 {max-height: 56px;}.min-width-8 {min-width: 64px;}.min-height-8 {min-height: 64px;}.max-width-8 {max-width: 64px;}.max-height-8 {max-height: 64px;}.min-width-9 {min-width: 72px;}.min-height-9 {min-height: 72px;}.max-width-9 {max-width: 72px;}.max-height-9 {max-height: 72px;}.min-width-10 {min-width: 80px;}.min-height-10 {min-height: 80px;}.max-width-10 {max-width: 80px;}.max-height-10 {max-height: 80px;}.min-width-11 {min-width: 88px;}.min-height-11 {min-height: 88px;}.max-width-11 {max-width: 88px;}.max-height-11 {max-height: 88px;}.min-width-12 {min-width: 96px;}.min-height-12 {min-height: 96px;}.max-width-12 {max-width: 96px;}.max-height-12 {max-height: 96px;}.min-width-13 {min-width: 104px;}.min-height-13 {min-height: 104px;}.max-width-13 {max-width: 104px;}.max-height-13 {max-height: 104px;}.min-width-14 {min-width: 112px;}.min-height-14 {min-height: 112px;}.max-width-14 {max-width: 112px;}.max-height-14 {max-height: 112px;}.min-width-15 {min-width: 120px;}.min-height-15 {min-height: 120px;}.max-width-15 {max-width: 120px;}.max-height-15 {max-height: 120px;}.min-width-16 {min-width: 128px;}.min-height-16 {min-height: 128px;}.max-width-16 {max-width: 128px;}.max-height-16 {max-height: 128px;}.min-width-17 {min-width: 136px;}.min-height-17 {min-height: 136px;}.max-width-17 {max-width: 136px;}.max-height-17 {max-height: 136px;}.min-width-18 {min-width: 144px;}.min-height-18 {min-height: 144px;}.max-width-18 {max-width: 144px;}.max-height-18 {max-height: 144px;}.min-width-19 {min-width: 152px;}.min-height-19 {min-height: 152px;}.max-width-19 {max-width: 152px;}.max-height-19 {max-height: 152px;}.min-width-20 {min-width: 160px;}.min-height-20 {min-height: 160px;}.max-width-20 {max-width: 160px;}.max-height-20 {max-height: 160px;}.min-width-21 {min-width: 168px;}.min-height-21 {min-height: 168px;}.max-width-21 {max-width: 168px;}.max-height-21 {max-height: 168px;}.min-width-22 {min-width: 176px;}.min-height-22 {min-height: 176px;}.max-width-22 {max-width: 176px;}.max-height-22 {max-height: 176px;}.min-width-23 {min-width: 184px;}.min-height-23 {min-height: 184px;}.max-width-23 {max-width: 184px;}.max-height-23 {max-height: 184px;}.min-width-24 {min-width: 192px;}.min-height-24 {min-height: 192px;}.max-width-24 {max-width: 192px;}.max-height-24 {max-height: 192px;}.min-width-25 {min-width: 200px;}.min-height-25 {min-height: 200px;}.max-width-25 {max-width: 200px;}.max-height-25 {max-height: 200px;}.min-width-26 {min-width: 208px;}.min-height-26 {min-height: 208px;}.max-width-26 {max-width: 208px;}.max-height-26 {max-height: 208px;}.min-width-27 {min-width: 216px;}.min-height-27 {min-height: 216px;}.max-width-27 {max-width: 216px;}.max-height-27 {max-height: 216px;}.min-width-28 {min-width: 224px;}.min-height-28 {min-height: 224px;}.max-width-28 {max-width: 224px;}.max-height-28 {max-height: 224px;}.min-width-29 {min-width: 232px;}.min-height-29 {min-height: 232px;}.max-width-29 {max-width: 232px;}.max-height-29 {max-height: 232px;}.min-width-30 {min-width: 240px;}.min-height-30 {min-height: 240px;}.max-width-30 {max-width: 240px;}.max-height-30 {max-height: 240px;}.min-width-40 {min-width: 320px;}.min-height-40 {min-height: 320px;}.max-width-40 {max-width: 320px;}.max-height-40 {max-height: 320px;}.min-width-50 {min-width: 400px;}.min-height-50 {min-height: 400px;}.max-width-50 {max-width: 400px;}.max-height-50 {max-height: 400px;}.min-width-60 {min-width: 480px;}.min-height-60 {min-height: 480px;}.max-width-60 {max-width: 480px;}.max-height-60 {max-height: 480px;}.min-width-70 {min-width: 560px;}.min-height-70 {min-height: 560px;}.max-width-70 {max-width: 560px;}.max-height-70 {max-height: 560px;}.min-width-80 {min-width: 640px;}.min-height-80 {min-height: 640px;}.max-width-80 {max-width: 640px;}.max-height-80 {max-height: 640px;}.min-width-90 {min-width: 720px;}.min-height-90 {min-height: 720px;}.max-width-90 {max-width: 720px;}.max-height-90 {max-height: 720px;}.min-width-100 {min-width: 800px;}.min-height-100 {min-height: 800px;}.max-width-100 {max-width: 800px;}.max-height-100 {max-height: 800px;}.min-width-110 {min-width: 880px;}.min-height-110 {min-height: 880px;}.max-width-110 {max-width: 880px;}.max-height-110 {max-height: 880px;}.min-width-120 {min-width: 960px;}.min-height-120 {min-height: 960px;}.max-width-120 {max-width: 960px;}.max-height-120 {max-height: 960px;}.min-width-36 {min-width: 288px;}.max-height-51 {max-height: 408px;}.max-height-inherit {max-height: inherit;}.valign-baseline {vertical-align: baseline;}.valign-text-top {vertical-align: text-top;}.valign-top {vertical-align: top;}.valign-middle {vertical-align: middle;}.valign-bottom {vertical-align: bottom;}.font-family-inherit {font-family: inherit;}.font-size-inherit {font-size: inherit;}.text-decoration-none {text-decoration: none;}.bold {font-weight: bold;}.regular {font-weight: normal;}.italic {font-style: italic;}.strikethrough {text-decoration: line-through;}.underline {text-decoration: underline;}.caps {text-transform: uppercase;letter-spacing: 1px;}.lowercase {text-transform: lowercase;}.capitalize {text-transform: capitalize;}.align-left {text-align: left;}.align-center {text-align: center;}.align-right {text-align: right;}.align-justify {text-align: justify;}.nowrap {white-space: nowrap;}.break-word {word-wrap: break-word;}.line-height-1 {line-height: 24px;}.line-height-2 {line-height: 48px;}.line-height-3 {line-height: 72px;}.line-height-4 {line-height: 96px;}.list-style-none {list-style: none;}.ellipsis {overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;white-space: nowrap;}.list-reset {list-style: none;padding-left: 0;}.text-overflow-initial {-o-text-overflow: initial;text-overflow: initial;}.transition-property-all {-webkit-transition-property: all;-moz-transition-property: all;-o-transition-property: all;-ms-transition-property: all;transition-property: all;}.transition-property-opacity {-webkit-transition-property: opacity;-moz-transition-property: opacity;-o-transition-property: opacity;-ms-transition-property: opacity;transition-property: opacity;}.transition-duration-sec1 {-webkit-transition-duration: 1s;-moz-transition-duration: 1s;-o-transition-duration: 1s;-ms-transition-duration: 1s;transition-duration: 1s;}.transition-duration-sec1_5 {-webkit-transition-duration: 1.5s;-moz-transition-duration: 1.5s;-o-transition-duration: 1.5s;-ms-transition-duration: 1.5s;transition-duration: 1.5s;}.transition-duration-sec2 {-webkit-transition-duration: 2s;-moz-transition-duration: 2s;-o-transition-duration: 2s;-ms-transition-duration: 2s;transition-duration: 2s;}.transition-duration-sec2_5 {-webkit-transition-duration: 2.5s;-moz-transition-duration: 2.5s;-o-transition-duration: 2.5s;-ms-transition-duration: 2.5s;transition-duration: 2.5s;}.transition-duration-sec3 {-webkit-transition-duration: 3s;-moz-transition-duration: 3s;-o-transition-duration: 3s;-ms-transition-duration: 3s;transition-duration: 3s;}.transition-duration-sec3_5 {-webkit-transition-duration: 3.5s;-moz-transition-duration: 3.5s;-o-transition-duration: 3.5s;-ms-transition-duration: 3.5s;transition-duration: 3.5s;}.transition-duration-sec4 {-webkit-transition-duration: 4s;-moz-transition-duration: 4s;-o-transition-duration: 4s;-ms-transition-duration: 4s;transition-duration: 4s;}.transition-duration-sec4_5 {-webkit-transition-duration: 4.5s;-moz-transition-duration: 4.5s;-o-transition-duration: 4.5s;-ms-transition-duration: 4.5s;transition-duration: 4.5s;}.transition-duration-sec5 {-webkit-transition-duration: 5s;-moz-transition-duration: 5s;-o-transition-duration: 5s;-ms-transition-duration: 5s;transition-duration: 5s;}.transition-duration-sec6 {-webkit-transition-duration: 6s;-moz-transition-duration: 6s;-o-transition-duration: 6s;-ms-transition-duration: 6s;transition-duration: 6s;}.transition-duration-sec7 {-webkit-transition-duration: 7s;-moz-transition-duration: 7s;-o-transition-duration: 7s;-ms-transition-duration: 7s;transition-duration: 7s;}.transition-duration-sec8 {-webkit-transition-duration: 8s;-moz-transition-duration: 8s;-o-transition-duration: 8s;-ms-transition-duration: 8s;transition-duration: 8s;}.transition-duration-sec9 {-webkit-transition-duration: 9s;-moz-transition-duration: 9s;-o-transition-duration: 9s;-ms-transition-duration: 9s;transition-duration: 9s;}.transition-duration-sec10 {-webkit-transition-duration: 10s;-moz-transition-duration: 10s;-o-transition-duration: 10s;-ms-transition-duration: 10s;transition-duration: 10s;}.transition-duration-ms100 {-webkit-transition-duration: 100ms;-moz-transition-duration: 100ms;-o-transition-duration: 100ms;-ms-transition-duration: 100ms;transition-duration: 100ms;}.transition-duration-ms200 {-webkit-transition-duration: 200ms;-moz-transition-duration: 200ms;-o-transition-duration: 200ms;-ms-transition-duration: 200ms;transition-duration: 200ms;}.transition-duration-ms300 {-webkit-transition-duration: 300ms;-moz-transition-duration: 300ms;-o-transition-duration: 300ms;-ms-transition-duration: 300ms;transition-duration: 300ms;}.transition-duration-ms400 {-webkit-transition-duration: 400ms;-moz-transition-duration: 400ms;-o-transition-duration: 400ms;-ms-transition-duration: 400ms;transition-duration: 400ms;}.transition-duration-ms500 {-webkit-transition-duration: 500ms;-moz-transition-duration: 500ms;-o-transition-duration: 500ms;-ms-transition-duration: 500ms;transition-duration: 500ms;}.transition-duration-ms600 {-webkit-transition-duration: 600ms;-moz-transition-duration: 600ms;-o-transition-duration: 600ms;-ms-transition-duration: 600ms;transition-duration: 600ms;}.transition-duration-ms700 {-webkit-transition-duration: 700ms;-moz-transition-duration: 700ms;-o-transition-duration: 700ms;-ms-transition-duration: 700ms;transition-duration: 700ms;}.transition-duration-ms800 {-webkit-transition-duration: 800ms;-moz-transition-duration: 800ms;-o-transition-duration: 800ms;-ms-transition-duration: 800ms;transition-duration: 800ms;}.transition-duration-ms900 {-webkit-transition-duration: 900ms;-moz-transition-duration: 900ms;-o-transition-duration: 900ms;-ms-transition-duration: 900ms;transition-duration: 900ms;}.transition-tf-ease {-webkit-transition-timing-function: ease;-moz-transition-timing-function: ease;-o-transition-timing-function: ease;-ms-transition-timing-function: ease;transition-timing-function: ease;}.transition-tf-linear {-webkit-transition-timing-function: linear;-moz-transition-timing-function: linear;-o-transition-timing-function: linear;-ms-transition-timing-function: linear;transition-timing-function: linear;}.transition-tf-ease-in {-webkit-transition-timing-function: ease-in;-moz-transition-timing-function: ease-in;-o-transition-timing-function: ease-in;-ms-transition-timing-function: ease-in;transition-timing-function: ease-in;}.transition-tf-ease-out {-webkit-transition-timing-function: ease-out;-moz-transition-timing-function: ease-out;-o-transition-timing-function: ease-out;-ms-transition-timing-function: ease-out;transition-timing-function: ease-out;}.transition-tf-ease-in-out {-webkit-transition-timing-function: ease-in-out;-moz-transition-timing-function: ease-in-out;-o-transition-timing-function: ease-in-out;-ms-transition-timing-function: ease-in-out;transition-timing-function: ease-in-out;}.transition-tf-step-start {-webkit-transition-timing-function: step-start;-moz-transition-timing-function: step-start;-o-transition-timing-function: step-start;-ms-transition-timing-function: step-start;transition-timing-function: step-start;}.transition-tf-step-end {-webkit-transition-timing-function: step-end;-moz-transition-timing-function: step-end;-o-transition-timing-function: step-end;-ms-transition-timing-function: step-end;transition-timing-function: step-end;}.transition-delay-sec1 {-webkit-transition-delay: 1s;-moz-transition-delay: 1s;-o-transition-delay: 1s;-ms-transition-delay: 1s;transition-delay: 1s;}.transition-delay-sec1_5 {-webkit-transition-delay: 1.5s;-moz-transition-delay: 1.5s;-o-transition-delay: 1.5s;-ms-transition-delay: 1.5s;transition-delay: 1.5s;}.transition-delay-sec2 {-webkit-transition-delay: 2s;-moz-transition-delay: 2s;-o-transition-delay: 2s;-ms-transition-delay: 2s;transition-delay: 2s;}.transition-delay-sec2_5 {-webkit-transition-delay: 2.5s;-moz-transition-delay: 2.5s;-o-transition-delay: 2.5s;-ms-transition-delay: 2.5s;transition-delay: 2.5s;}.transition-delay-sec3 {-webkit-transition-delay: 3s;-moz-transition-delay: 3s;-o-transition-delay: 3s;-ms-transition-delay: 3s;transition-delay: 3s;}.transition-delay-sec3_5 {-webkit-transition-delay: 3.5s;-moz-transition-delay: 3.5s;-o-transition-delay: 3.5s;-ms-transition-delay: 3.5s;transition-delay: 3.5s;}.transition-delay-sec4 {-webkit-transition-delay: 4s;-moz-transition-delay: 4s;-o-transition-delay: 4s;-ms-transition-delay: 4s;transition-delay: 4s;}.transition-delay-sec4_5 {-webkit-transition-delay: 4.5s;-moz-transition-delay: 4.5s;-o-transition-delay: 4.5s;-ms-transition-delay: 4.5s;transition-delay: 4.5s;}.transition-delay-sec5 {-webkit-transition-delay: 5s;-moz-transition-delay: 5s;-o-transition-delay: 5s;-ms-transition-delay: 5s;transition-delay: 5s;}.transition-delay-sec6 {-webkit-transition-delay: 6s;-moz-transition-delay: 6s;-o-transition-delay: 6s;-ms-transition-delay: 6s;transition-delay: 6s;}.transition-delay-sec7 {-webkit-transition-delay: 7s;-moz-transition-delay: 7s;-o-transition-delay: 7s;-ms-transition-delay: 7s;transition-delay: 7s;}.transition-delay-sec8 {-webkit-transition-delay: 8s;-moz-transition-delay: 8s;-o-transition-delay: 8s;-ms-transition-delay: 8s;transition-delay: 8s;}.transition-delay-sec9 {-webkit-transition-delay: 9s;-moz-transition-delay: 9s;-o-transition-delay: 9s;-ms-transition-delay: 9s;transition-delay: 9s;}.transition-delay-sec10 {-webkit-transition-delay: 10s;-moz-transition-delay: 10s;-o-transition-delay: 10s;-ms-transition-delay: 10s;transition-delay: 10s;}.transition-delay-ms100 {-webkit-transition-delay: 100ms;-moz-transition-delay: 100ms;-o-transition-delay: 100ms;-ms-transition-delay: 100ms;transition-delay: 100ms;}.transition-delay-ms200 {-webkit-transition-delay: 200ms;-moz-transition-delay: 200ms;-o-transition-delay: 200ms;-ms-transition-delay: 200ms;transition-delay: 200ms;}.transition-delay-ms300 {-webkit-transition-delay: 300ms;-moz-transition-delay: 300ms;-o-transition-delay: 300ms;-ms-transition-delay: 300ms;transition-delay: 300ms;}.transition-delay-ms400 {-webkit-transition-delay: 400ms;-moz-transition-delay: 400ms;-o-transition-delay: 400ms;-ms-transition-delay: 400ms;transition-delay: 400ms;}.transition-delay-ms500 {-webkit-transition-delay: 500ms;-moz-transition-delay: 500ms;-o-transition-delay: 500ms;-ms-transition-delay: 500ms;transition-delay: 500ms;}.transition-delay-ms600 {-webkit-transition-delay: 600ms;-moz-transition-delay: 600ms;-o-transition-delay: 600ms;-ms-transition-delay: 600ms;transition-delay: 600ms;}.transition-delay-ms700 {-webkit-transition-delay: 700ms;-moz-transition-delay: 700ms;-o-transition-delay: 700ms;-ms-transition-delay: 700ms;transition-delay: 700ms;}.transition-delay-ms800 {-webkit-transition-delay: 800ms;-moz-transition-delay: 800ms;-o-transition-delay: 800ms;-ms-transition-delay: 800ms;transition-delay: 800ms;}.transition-delay-ms900 {-webkit-transition-delay: 900ms;-moz-transition-delay: 900ms;-o-transition-delay: 900ms;-ms-transition-delay: 900ms;transition-delay: 900ms;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5 {color: #fff;}.theme-inverse a {color: inherit;}.theme-inverse a:hover {color: #a6daff;}.theme-inverse a:active {color: #bfe5ff;}.theme-inverse a.text-muted {color: #b1b1b3;}.theme-inverse hr {background: #555659;}.theme-inverse .mo-identicon {background-color: #555659;color: #fff;}.theme-inverse .menu-row.hover {background: #222326;}.theme-inverse .menu-row.active {color: #fff;background: #222326;}.theme-inverse .menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse a.menu-row {color: inherit;}.theme-inverse a.menu-row:hover {background: #222326;}.theme-inverse a.menu-row:active {color: #fff;background: #222326;}.theme-inverse .menu-divider {border-color: #555659;}.theme-inverse .text-color-heading {color: #fff;}.theme-inverse .text-color-body {color: #d7d7d9;}.theme-inverse .text-muted {color: #b1b1b3;}.theme-inverse .text-positive {color: #8ae58a;}.theme-inverse .text-muted-positive {color: #39bf71;}.theme-inverse .text-negative {color: #f99;}.theme-inverse .text-muted-negative {color: #f26161;}.theme-inverse .nav-link,.momentum-body .theme-inverse .nav-link {color: #b1b1b3;}.theme-inverse .nav-link:hover,.momentum-body .theme-inverse .nav-link:hover {color: #a6daff;}.theme-inverse .nav-link:active,.momentum-body .theme-inverse .nav-link:active {color: #bfe5ff;}.theme-inverse a.tab-link,.momentum-body .theme-inverse a.tab-link {color: #d7d7d9;}.theme-inverse a.tab-link:hover,.momentum-body .theme-inverse a.tab-link:hover {border-bottom-color: #969799;color: #fff;}.theme-inverse a.tab-link:active,.momentum-body .theme-inverse a.tab-link:active {border-bottom-color: #d7d7d9;color: #d7d7d9;}.theme-inverse a.tab-link.selected,.momentum-body .theme-inverse a.tab-link.selected {color: #fff;}.theme-inverse .list-row {border-bottom: 1px solid #555659;border-top: 1px solid #555659;}.theme-inverse .upload {background-color: #3b3d3f;border-color: #555659;color: #969799;}.theme-inverse .upload:hover,.theme-inverse .upload.hover {background-color: #707173;}.theme-inverse .border {border-color: #555659;}.theme-inverse .border-top {border-top-color: #555659;}.theme-inverse .border-right {border-right-color: #555659;}.theme-inverse .border-bottom {border-bottom-color: #555659;}.theme-inverse .border-left {border-left-color: #555659;}@media (max-width: 575px) {.display-none-xs {display: none;}.display-inline-xs,.inline-xs {display: inline;}.display-block-cx,.block-xs {display: block;}.display-inline-block-xs,.inline-block-xs {display: inline-block;}.display-table-xs,.table-xs {display: table;}.display-table-cell-xs,.table-cell-xs {display: table-cell;}.display-flex-xs,.flex-xs {display: flex;}}@media (min-width: 576px) {.container,.container-sm {max-width: 540px;width: auto;}.col-sm {flex: 1 1 0%;min-width: 0;width: 100%;}.col-sm-auto {flex: 0 0 auto;width: auto;}.col-sm-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-sm-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-sm-3 {flex: 0 0 25%;max-width: 25%;}.col-sm-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-sm-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-sm-6 {flex: 0 0 50%;max-width: 50%;}.col-sm-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-sm-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-sm-9 {flex: 0 0 75%;max-width: 75%;}.col-sm-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-sm-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-sm-12 {flex: 0 0 100%;max-width: 100%;}.display-none-sm {display: none;}.display-inline-sm {display: inline;}.display-block-sm {display: block;}.display-inline-block-sm {display: inline-block;}.display-table-sm {display: table;}.display-table-cell-sm {display: table-cell;}.display-flex-sm {display: flex;}}@media (min-width: 768px) {.container,.container-sm,.container-md {max-width: 720px;width: auto;}.col-md {flex: 1 1 0%;min-width: 0;width: 100%;}.col-md-auto {flex: 0 0 auto;width: auto;}.col-md-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-md-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-md-3 {flex: 0 0 25%;max-width: 25%;}.col-md-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-md-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-md-6 {flex: 0 0 50%;max-width: 50%;}.col-md-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-md-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-md-9 {flex: 0 0 75%;max-width: 75%;}.col-md-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-md-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-md-12 {flex: 0 0 100%;max-width: 100%;}.display-none-md {display: none;}.display-inline-md {display: inline;}.display-block-md {display: block;}.display-inline-block-md {display: inline-block;}.display-table-md {display: table;}.display-table-cell-md {display: table-cell;}.display-flex-md {display: flex;}}@media (min-width: 992px) {.container,.container-sm,.container-md,.container-lg {max-width: 960px;width: auto;}.col-lg {flex: 1 1 0%;min-width: 0;width: 100%;}.col-lg-auto {flex: 0 0 auto;width: auto;}.col-lg-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-lg-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-lg-3 {flex: 0 0 25%;max-width: 25%;}.col-lg-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-lg-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-lg-6 {flex: 0 0 50%;max-width: 50%;}.col-lg-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-lg-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-lg-9 {flex: 0 0 75%;max-width: 75%;}.col-lg-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-lg-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-lg-12 {flex: 0 0 100%;max-width: 100%;}.display-none-lg {display: none;}.display-inline-lg {display: inline;}.display-block-lg {display: block;}.display-inline-block-lg {display: inline-block;}.display-table-lg {display: table;}.display-table-cell-lg {display: table-cell;}.display-flex-lg {display: flex;}}@media (min-width: 1200px) {.container,.container-sm,.container-md,.container-lg,.container-xl {max-width: 1140px;width: auto;}.col-xl {flex: 1 1 0%;min-width: 0;width: 100%;}.col-xl-auto {flex: 0 0 auto;width: auto;}.col-xl-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-xl-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-xl-3 {flex: 0 0 25%;max-width: 25%;}.col-xl-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-xl-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-xl-6 {flex: 0 0 50%;max-width: 50%;}.col-xl-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-xl-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-xl-9 {flex: 0 0 75%;max-width: 75%;}.col-xl-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-xl-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-xl-12 {flex: 0 0 100%;max-width: 100%;}.display-none-xl {display: none;}.display-inline-xl {display: inline;}.display-block-xl {display: block;}.display-inline-block-xl {display: inline-block;}.display-table-xl {display: table;}.display-table-cell-xl {display: table-cell;}.display-flex-xl {display: flex;}}html {position: relative;min-height: 100%;}body {background: #f9f9f9;color: #515357;padding-top: 70px;padding-bottom: 250px;}a,a:visited {color: #737578;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.ttf") format('truetype');font-style: normal;font-weight: bold;text-rendering: optimizeLegibility;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.ttf") format('truetype');font-style: normal;font-weight: normal;text-rendering: optimizeLegibility;}body,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {color: #515357;font: normal 400 16px/1.8 Lato;}h1,h2,h3,h4,p,h5,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;display: block;}h1 {font: normal 700 48px/1.4 Lato;color: #fff;text-transform: uppercase;letter-spacing: 1px;}h2,h5 {font: normal 400 36px/1.4 Lato;color: #515357;text-transform: none;letter-spacing: 0px;}h3 {font: normal 700 18px/1.4 "Lato";color: #515357;}h4 {font: normal 700 16px/1.4 Lato;text-transform: uppercase;letter-spacing: 1px;color: #515357;}h5 {font-size: 24px;margin-right: 115px;overflow: hidden;-webkit-transition: color 150ms;-moz-transition: color 150ms;-o-transition: color 150ms;-ms-transition: color 150ms;transition: color 150ms;}h2,h3,h4 {margin: 17.5px 0;}p,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 17.5px 0;}p > a,.postings-link {text-decoration: underline;color: #737578;}p > a:hover,.postings-link:hover {color: #579eee;}p > a:active,.postings-link:active,p > a:focus,.postings-link:focus {color: #3c6ea6;}.page-full-width {width: 100%;}.page-centered,.g-recaptcha div,.h-captcha-spacing {display: block;margin: 0 auto;max-width: 1080px;}.content-wrapper {min-height: 100%;}.content {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;min-height: 100%;position: relative;width: 100%;}.row {left: 0;position: absolute;right: 0;}.column-wrapper {display: table;height: 100%;width: 100%;}.table-row {display: table-row;}.column {display: table-cell;position: relative;vertical-align: middle;}.third {width: 33.33%;}.two-thirds {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;padding-left: 40px;width: 66.67%;}.section-wrapper {padding: 0 30px;}.section {padding: 20px 0;position: relative;}.narrow-section,.application .section,.eeo-survey .section,.list .section,.show .section {max-width: 760px;padding-left: 0;padding-right: 0;}.accent-section {background: #fff;}.accent-section.small-accent {padding: 0 30px;}.accent-section .posting-categories {margin: 20px 0;}.accent-section .posting-category {display: inline-block;font-size: 14px;margin-right: 10px;}.split-width-container,.show .posting-header {display: block;}.left-block,.right-block,.left-float,.right-float,.full-block {display: block;width: auto;}.left-block {overflow: hidden;}.right-float {float: right;margin-left: 10px;}.right-block {overflow: hidden;}.left-float {float: left;margin-right: 10px;}.full-block {width: 100%;}.template-btn,.template-btn-submit,.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {font: normal 700 14px/1.4 Lato;text-transform: uppercase;letter-spacing: 2px;text-align: center;border-radius: 3px;color: #fff;background: #00a1dc;height: auto;position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 10px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.template-btn .filename,.template-btn-submit .filename,.template-btn-utility .filename,.sort-category .filename,.application .application-field .upload-file-overlay .filename,.eeo-survey .application-field .upload-file-overlay .filename,.list .filter-button-wrapper .filter-button .filename,.template-btn .default-label,.template-btn-submit .default-label,.template-btn-utility .default-label,.sort-category .default-label,.application .application-field .upload-file-overlay .default-label,.eeo-survey .application-field .upload-file-overlay .default-label,.list .filter-button-wrapper .filter-button .default-label {line-height: 1.33;display: block;overflow: hidden;}.template-btn:visited,.template-btn-submit:visited,.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {color: #fff;}.template-btn .icon >svg,.template-btn-submit .icon >svg,.template-btn-utility .icon >svg,.sort-category .icon >svg,.application .application-field .upload-file-overlay .icon >svg,.eeo-survey .application-field .upload-file-overlay .icon >svg,.list .filter-button-wrapper .filter-button .icon >svg {fill: #fff;}.template-btn:hover,.template-btn-submit:hover,.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {color: #fff;}.template-btn:active,.template-btn-submit:active,.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #00709a;}.template-btn-submit {color: #fff;background: #00a1dc;border-color: #0098d1;}.template-btn-submit .icon >svg {fill: #fff;}.template-btn-submit:visited {color: #fff;}.template-btn-submit:hover {background: #0090c6;}.template-btn-submit:active,.template-btn-submit:focus {background: #00709a;}.template-btn-submit.cerulean {background-color: #0c92f3;border-color: #0b8ae6;}.template-btn-submit.cerulean:hover {background: #0a83da;}.template-btn-submit.cerulean:active,.template-btn-submit.cerulean:focus {background: #0866aa;}.template-btn-submit.teal {background-color: #1cadba;border-color: #1aa4b0;}.template-btn-submit.teal:hover {background: #199ba7;}.template-btn-submit.teal:active,.template-btn-submit.teal:focus {background: #137982;}.template-btn-submit.shamrock {background-color: #39bf71;border-color: #36b56b;}.template-btn-submit.shamrock:hover {background: #33ab65;}.template-btn-submit.shamrock:active,.template-btn-submit.shamrock:focus {background: #27854f;}.template-btn-submit.golden-poppy {background-color: #ffa60d;border-color: #f29d0c;}.template-btn-submit.golden-poppy:hover {background: #e5950b;}.template-btn-submit.golden-poppy:active,.template-btn-submit.golden-poppy:focus {background: #b27409;}.template-btn-submit.ruby {background-color: #d94141;border-color: #ce3d3d;}.template-btn-submit.ruby:hover {background: #c33a3a;}.template-btn-submit.ruby:active,.template-btn-submit.ruby:focus {background: #972d2d;}.template-btn-submit.ash {background-color: #969799;border-color: #8e8f91;}.template-btn-submit.ash:hover {background: #878789;}.template-btn-submit.ash:active,.template-btn-submit.ash:focus {background: #69696b;}.template-btn-submit.black {background-color: #000;border-color: #000;}.template-btn-submit.black:hover {background: #000;}.template-btn-submit.black:active,.template-btn-submit.black:focus {background: #000;}.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {background: #ebecf0;color: #9696a2;border: 1px solid #dfe0e4;}.template-btn-utility >svg,.sort-category >svg,.application .application-field .upload-file-overlay >svg,.eeo-survey .application-field .upload-file-overlay >svg,.list .filter-button-wrapper .filter-button >svg {fill: #9696a2;}.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited {color: #9696a2;background: #ebecf0;}.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {background: #dfe0e4;color: #5a5a61;}.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #d3d4d8;color: #5a5a61;}.template-btn-utility.has-file,.sort-category.has-file,.application .application-field .upload-file-overlay.has-file,.eeo-survey .application-field .upload-file-overlay.has-file,.list .filter-button-wrapper .filter-button.has-file {background: #dadbdf;}.template-btn .icon,.template-btn-submit .icon,.template-btn-utility .icon,.sort-category .icon,.application .application-field .upload-file-overlay .icon,.eeo-survey .application-field .upload-file-overlay .icon,.list .filter-button-wrapper .filter-button .icon {position: absolute;left: 15px;top: calc(50% - 8px);}.posting-btn-submit {padding: 5px 15px;}.main-header {background: #fff;color: #515357;}.main-header.section-wrapper,.main-header .section {padding-top: 0px;padding-bottom: 0px;}.main-header .main-header-logo {margin: 17.5px 0px;display: inline-block;}.main-header .main-header-logo img {height: 35px;}.main-header .mobile-menu svg >path {fill: #515357;}.main-header .main-header-content {display: block;height: 100%;margin: 0px auto;color: #515357;}.main-header .main-header-content .main-header-company {display: inline-block;height: 70px;vertical-align: middle;font-family: Lato;color: #515357;}.main-header {top: 0;height: 70px;}.main-header .main-logo,.main-header .mobile-menu {position: absolute;left: 30px;}.main-header .main-logo img,.main-header .mobile-menu img {height: 100%;position: absolute;}.main-header .main-logo {top: 50%;margin-top: -0.175px;height: 0.5;}.main-header .mobile-menu {position: absolute;right: 0px;top: 50%;margin-top: -0.15px;height: 0.6;left: auto;right: 30px;}.main-header .mobile-menu img {right: 0px;}.main-header .main-header-content .main-header-company {line-height: 70px;}.main-header .main-header-content .main-header-company .icon,.main-header .main-header-content .main-header-company span {height: 70px;display: inline-block;float: left;height: 70px;}.main-header .main-header-content .main-header-company .icon {margin-right: 10px;}@media screen {.main-header {position: fixed;z-index: 100;top: 0;overflow: hidden;}}.header-comfortable {margin-top: 40px;}.header-comfortable .main-header-logo img {height: 77px;}.header-comfortable .main-header {height: 110px;}.main-footer {margin: 0;color: #7f838a;background: #edeef1;}.main-footer .image-link {display: inline-block;color: #7f838a;margin: 40px 0px;}.main-footer .image-link span,.main-footer .image-link img {display: inline-block;position: relative;height: 24px;}.main-footer .image-link span {margin-right: 10px;}.main-footer .image-link img {vertical-align: -6px;}.main-footer .image-link:hover,.main-footer .image-link:visited {color: #7f838a;}.main-footer p {color: #7f838a;}.main-footer a {color: #579eee;border-bottom: 1px solid #78b1f1;text-decoration: none;}.main-footer a:visited {color: #579eee;}.main-footer a:hover {color: #4e8ed6;}.main-footer a.image-link {border-bottom: none;}.main-footer {position: absolute;bottom: 0;width: 100%;height: 250px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.main-footer-text {text-align: center;padding: 40px 30px;}.main-footer-text p {display: block;max-width: 500px;margin: 0px auto;}.posting-header h2 {margin-top: 0px;}.posting-page .section.page-centered li {margin: 8px 0px 8px 17px;list-style-position: outside;}.posting-page .section.page-centered ul li {list-style-type: disc;}.medium-utility-label,.small-utility-label {color: #808080;font: normal 700 16px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.large-category-label,.medium-category-label,.small-category-label,.button-utility-label {color: #808080;font: normal 700 24px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.medium-category-label,.button-utility-label {font-size: 14px;}.small-utility-label {font-size: 12px;line-height: 1.4;}.large-category-header {font: normal 700 30px/1.4 Lato;letter-spacing: 1px;margin-bottom: 25px;text-transform: uppercase;}.medium-category-label.capitalize-labels {text-transform: capitalize;}.small-category-label {font-size: 12px;line-height: 1.4;}.button-utility-label {text-transform: none;}.vertical-line,.horizontal-line {border-color: #e2e2e2;}.vertical-line {position: absolute;left: 0px;top: 30%;height: 40%;width: 1px;border-left-width: 1px;border-left-style: solid;}.horizontal-line {margin: 20px auto 20px auto;width: 80px;height: 1px;border-bottom-width: 1px;border-bottom-style: solid;}.confirmation-message {text-align: center;}.confirmation-message .template-btn-submit {margin-top: 16px;}.cc-window{opacity:1;-webkit-transition:opacity 1s ease;transition:opacity 1s ease}.cc-window.cc-invisible{opacity:0}.cc-animate.cc-revoke{-webkit-transition:transform 1s ease;-webkit-transition:-webkit-transform 1s ease;transition:-webkit-transform 1s ease;transition:transform 1s ease;transition:transform 1s ease,-webkit-transform 1s ease}.cc-animate.cc-revoke.cc-top{-webkit-transform:translateY(-2em);transform:translateY(-2em)}.cc-animate.cc-revoke.cc-bottom{-webkit-transform:translateY(2em);transform:translateY(2em)}.cc-animate.cc-revoke.cc-active.cc-top{-webkit-transform:translateY(0);transform:translateY(0)}.cc-animate.cc-revoke.cc-active.cc-bottom{-webkit-transform:translateY(0);transform:translateY(0)}.cc-revoke:hover{-webkit-transform:translateY(0);transform:translateY(0)}.cc-grower{max-height:0;overflow:hidden;-webkit-transition:max-height 1s;transition:max-height 1s}.cc-revoke,.cc-window{position:fixed;overflow:hidden;-webkit-box-sizing:border-box;box-sizing:border-box;font-family:Helvetica,Calibri,Arial,sans-serif;font-size:16px;line-height:1.5em;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:nowrap;flex-wrap:nowrap;z-index:9999}.cc-window.cc-static{position:static}.cc-window.cc-floating{padding:2em;max-width:24em;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner{padding:1em 1.8em;width:100%;-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}.cc-revoke{padding:.5em}.cc-revoke:hover{text-decoration:underline}.cc-header{font-size:18px;font-weight:700}.cc-btn,.cc-close,.cc-link,.cc-revoke{cursor:pointer}.cc-link{opacity:.8;display:inline-block;padding:.2em;text-decoration:underline}.cc-link:hover{opacity:1}.cc-link:active,.cc-link:visited{color:initial}.cc-btn{display:block;padding:.4em .8em;font-size:.9em;font-weight:700;border-width:2px;border-style:solid;text-align:center;white-space:nowrap}.cc-highlight .cc-btn:first-child{background-color:transparent;border-color:transparent}.cc-highlight .cc-btn:first-child:focus,.cc-highlight .cc-btn:first-child:hover{background-color:transparent;text-decoration:underline}.cc-close{display:block;position:absolute;top:.5em;right:.5em;font-size:1.6em;opacity:.9;line-height:.75}.cc-close:focus,.cc-close:hover{opacity:1}.cc-revoke.cc-top{top:0;left:3em;border-bottom-left-radius:.5em;border-bottom-right-radius:.5em}.cc-revoke.cc-bottom{bottom:0;left:3em;border-top-left-radius:.5em;border-top-right-radius:.5em}.cc-revoke.cc-left{left:3em;right:unset}.cc-revoke.cc-right{right:3em;left:unset}.cc-top{top:1em}.cc-left{left:1em}.cc-right{right:1em}.cc-bottom{bottom:1em}.cc-floating>.cc-link{margin-bottom:1em}.cc-floating .cc-message{display:block;margin-bottom:1em}.cc-window.cc-floating .cc-compliance{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto}.cc-window.cc-banner{-webkit-box-align:center;-ms-flex-align:center;align-items:center}.cc-banner.cc-top{left:0;right:0;top:0}.cc-banner.cc-bottom{left:0;right:0;bottom:0}.cc-banner .cc-message{display:block;-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto;max-width:100%;margin-right:1em}.cc-compliance{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-ms-flex-line-pack:justify;align-content:space-between}.cc-floating .cc-compliance>.cc-btn{-webkit-box-flex:1;-ms-flex:1;flex:1}.cc-btn+.cc-btn{margin-left:.5em}@media print{.cc-revoke,.cc-window{display:none}}@media screen and (max-width:900px){.cc-btn{white-space:normal}}@media screen and (max-width:414px) and (orientation:portrait),screen and (max-width:736px) and (orientation:landscape){.cc-window.cc-top{top:0}.cc-window.cc-bottom{bottom:0}.cc-window.cc-banner,.cc-window.cc-floating,.cc-window.cc-left,.cc-window.cc-right{left:0;right:0}.cc-window.cc-banner{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner .cc-compliance{-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto}.cc-window.cc-floating{max-width:none}.cc-window .cc-message{margin-bottom:1em}.cc-window.cc-banner{-webkit-box-align:unset;-ms-flex-align:unset;align-items:unset}.cc-window.cc-banner .cc-message{margin-right:0}}.cc-floating.cc-theme-classic{padding:1.2em;border-radius:5px}.cc-floating.cc-type-info.cc-theme-classic .cc-compliance{text-align:center;display:inline;-webkit-box-flex:0;-ms-flex:none;flex:none}.cc-theme-classic .cc-btn{border-radius:5px}.cc-theme-classic .cc-btn:last-child{min-width:140px}.cc-floating.cc-type-info.cc-theme-classic .cc-btn{display:inline-block}.cc-theme-edgeless.cc-window{padding:0}.cc-floating.cc-theme-edgeless .cc-message{margin:2em;margin-bottom:1.5em}.cc-banner.cc-theme-edgeless .cc-btn{margin:0;padding:.8em 1.8em;height:100%}.cc-banner.cc-theme-edgeless .cc-message{margin-left:1em}.cc-floating.cc-theme-edgeless .cc-btn+.cc-btn{margin-left:0}.cc-btn {border-width: 1px;display: inline;font-weight: normal;}.cc-link {color: inherit;}.cc-link:hover {color: #a6daff;}.cc-revoke {display: none;}.cc-window,.cc-revoke {background: #3b3d3f;border-radius: 8px 8px 0 0;color: #d7d7d9;font: inherit;}.cc-window.cc-banner,.cc-window.cc-floating {padding: 16px;}.cc-window.cc-floating {bottom: 0;min-width: 100%;}.cc-window {padding: 16px;}.cc-window .cc-mobile {display: none;}.cc-window .message-inverse {background: #222326;border-radius: 8px 8px 0 0;}.cc-window .momentum-body {margin: -16px;width: calc(100% + 32px);}.cc-window .momentum-body .cookie-banner-link {white-space: nowrap;}.cc-window .momentum-body .message {padding: 16px 16px 16px 48px;}.cc-window .momentum-body .message .icon {font-size: 24px;left: 16px;top: 16px;}.cc-window .message-buttons {margin-right: 16px;margin-top: 12px;}.cc-window h4 {color: #fff;margin-bottom: 4px;}@media screen and (max-width: 1150px) {.cc-window .cc-desktop {display: none;}.cc-window .cc-mobile {display: block;margin-top: 16px;}.cc-window .message {display: flex;}}.error-section {text-align: center;}.error-section img {margin-top: 70px;margin-bottom: 16px;}.application-question input,.application-additional input,.application-question textarea,.application-additional textarea {border-color: #e2e2e2;}.application-question input:active,.application-additional input:active,.application-question textarea:active,.application-additional textarea:active,.application-question input:focus,.application-additional input:focus,.application-question textarea:focus,.application-additional textarea:focus {border-color: #7f838a;}.application-question select,.application-additional select {background: #e2e2e2;border-color: transparent;}.application-question select:hover,.application-additional select:hover {background: #c0c0c0;}.application-question.custom-question,.application-additional.custom-question {display: grid;}.application-question.custom-question .application-label.multiple-choice,.application-additional.custom-question .application-label.multiple-choice,.application-question.custom-question .application-label.multiple-select,.application-additional.custom-question .application-label.multiple-select,.application-question.custom-question .application-label.textarea,.application-additional.custom-question .application-label.textarea,.application-question.custom-question .application-label.dropdown,.application-additional.custom-question .application-label.dropdown {margin-bottom: 0px;}.application-question.custom-question .application-field,.application-additional.custom-question .application-field {display: inline-block;}.application-question.custom-question .application-field input[type=text],.application-additional.custom-question .application-field input[type=text],.application-question.custom-question .application-field input[type=email],.application-additional.custom-question .application-field input[type=email],.application-question.custom-question .application-field input[type=tel],.application-additional.custom-question .application-field input[type=tel] {margin-top: 0px;}.application-question.custom-question .application-field input[type=radio],.application-additional.custom-question .application-field input[type=radio],.application-question.custom-question .application-field input[type=checkbox],.application-additional.custom-question .application-field input[type=checkbox] {left: 0px;}.application-question.custom-question .application-field .upload-file-overlay,.application-additional.custom-question .application-field .upload-file-overlay {margin-bottom: 17.5px;}.application-question.custom-question .application-field ul label,.application-additional.custom-question .application-field ul label {padding-left: 30px;}.application .application-question,.eeo-survey .application-question {list-style-type: none;padding: 0px 0px;}.application .application-label,.eeo-survey .application-label {font-size: 16px;line-height: 1.4;vertical-align: middle;width: 100%;}.application .application-label .description,.eeo-survey .application-label .description {font-size: 12px;margin-bottom: 0;}.application .application-label label,.eeo-survey .application-label label {position: relative;}.application .application-label.multiple-choice,.eeo-survey .application-label.multiple-choice,.application .application-label.multiple-select,.eeo-survey .application-label.multiple-select,.application .application-label.textarea,.eeo-survey .application-label.textarea {vertical-align: top;}.application .application-label.text,.eeo-survey .application-label.text {vertical-align: bottom;}.application .application-field,.eeo-survey .application-field {position: relative;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.application .application-field input[type=text],.eeo-survey .application-field input[type=text],.application .application-field select,.eeo-survey .application-field select,.application .application-field input[type=email],.eeo-survey .application-field input[type=email],.application .application-field input[type=tel],.eeo-survey .application-field input[type=tel] {display: inline-block;width: 100%;}.application .application-field input[type=text][disabled],.eeo-survey .application-field input[type=text][disabled],.application .application-field select[disabled],.eeo-survey .application-field select[disabled],.application .application-field input[type=email][disabled],.eeo-survey .application-field input[type=email][disabled],.application .application-field input[type=tel][disabled],.eeo-survey .application-field input[type=tel][disabled] {background-color: #e2e2e2;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {cursor: pointer;outline: none;}.application .application-field .icon-caret-down,.eeo-survey .application-field .icon-caret-down {height: 16px;width: 16px;position: absolute;right: 10px;margin-top: -8px;top: 50%;}.application .application-field ul,.eeo-survey .application-field ul {list-style-type: none;}.application .application-field label,.eeo-survey .application-field label {padding-left: 40px;position: relative;cursor: pointer;}.application .application-field label .application-answer-alternative,.eeo-survey .application-field label .application-answer-alternative {color: #83868c;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 20px;height: 20px;border-radius: 10px;position: relative;border: 1px solid #e2e2e2;}.application .application-field input[type=radio]:active,.eeo-survey .application-field input[type=radio]:active {background: #ebecf0;}.application .application-field input[type=radio]:checked::after,.eeo-survey .application-field input[type=radio]:checked::after {position: absolute;content: "";height: 20px;width: 20px;left: 0;top: 0;border-radius: 10px;background-color: #00a1dc;}.application .application-field input[type=radio]:checked + span,.eeo-survey .application-field input[type=radio]:checked + span,.application .application-field input[type=checkbox]:checked + span,.eeo-survey .application-field input[type=checkbox]:checked + span {color: #515357;}.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {width: 20px;height: 20px;border: 1px solid #e2e2e2;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-field input[type=checkbox]:active,.eeo-survey .application-field input[type=checkbox]:active {background: #ebecf0;}.application .application-field input[type=checkbox]:checked::after,.eeo-survey .application-field input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: -10%;height: 40%;width: 90%;border-bottom: 4px solid #00a1dc;border-left: 4px solid #00a1dc;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {position: absolute;left: 10px;top: 2px;}.application .application-field .application-university,.eeo-survey .application-field .application-university {position: relative;}.application .application-field .application-university .select2-container,.eeo-survey .application-field .application-university .select2-container {height: 40px;}.application .application-field .application-university .select2-container .select2-selection,.eeo-survey .application-field .application-university .select2-container .select2-selection {padding: 4px 4px 4px 7px;height: 40px;}.application .application-field .application-university .select2-container .select2-selection:active,.eeo-survey .application-field .application-university .select2-container .select2-selection:active,.application .application-field .application-university .select2-container .select2-selection:focus,.eeo-survey .application-field .application-university .select2-container .select2-selection:focus {outline: none;border: 1px solid #7f838a;}.application .application-field .application-university .select2-container .select2-selection span,.eeo-survey .application-field .application-university .select2-container .select2-selection span {font-size: 16px !important;}.application .application-field .application-university .select2-container .select2-selection__arrow,.eeo-survey .application-field .application-university .select2-container .select2-selection__arrow {top: 7px;}.application .application-field .application-dropdown,.eeo-survey .application-field .application-dropdown {position: relative;}.application .application-field .application-dropdown select,.eeo-survey .application-field .application-dropdown select {text-indent: 0.01px;-o-text-overflow: '';text-overflow: '';padding-right: 40px;}.application .application-field .application-dropdown select::-ms-expand,.eeo-survey .application-field .application-dropdown select::-ms-expand {display: none;}.application .application-field .application-dropdown::after,.eeo-survey .application-field .application-dropdown::after {position: absolute;content: "";right: 15px;top: 26px;height: 15px;width: 15px;border-bottom: 1px solid #7f838a;border-left: 1px solid #7f838a;border-color: #72767d;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);pointer-events: none;}.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay {max-width: 100%;padding-left: 41px;}.application .application-field .upload-file-overlay .icon-paperclip,.eeo-survey .application-field .upload-file-overlay .icon-paperclip {position: absolute;left: 15px;}.application .application-field input[type=file],.eeo-survey .application-field input[type=file] {position: absolute;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);top: 0;left: 0;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {font-size: 16px;line-height: 1.4;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {border-radius: 3px;border-width: 1px;border-style: solid;height: 40px;padding: 4px 4px 4px 15px;-webkit-transition: 1px solid #e3e4e6 150ms, background 150ms;-moz-transition: 1px solid #e3e4e6 150ms, background 150ms;-o-transition: 1px solid #e3e4e6 150ms, background 150ms;-ms-transition: 1px solid #e3e4e6 150ms, background 150ms;transition: 1px solid #e3e4e6 150ms, background 150ms;}.application .application-question input[type=text]:active,.eeo-survey .application-question input[type=text]:active,.application .application-additional input[type=text]:active,.eeo-survey .application-additional input[type=text]:active,.application .application-question input[type=email]:active,.eeo-survey .application-question input[type=email]:active,.application .application-additional input[type=email]:active,.eeo-survey .application-additional input[type=email]:active,.application .application-question input[type=tel]:active,.eeo-survey .application-question input[type=tel]:active,.application .application-additional input[type=tel]:active,.eeo-survey .application-additional input[type=tel]:active,.application .application-question textarea:active,.eeo-survey .application-question textarea:active,.application .application-additional textarea:active,.eeo-survey .application-additional textarea:active,.application .application-question select:active,.eeo-survey .application-question select:active,.application .application-additional select:active,.eeo-survey .application-additional select:active,.application .application-question input[type=text]:focus,.eeo-survey .application-question input[type=text]:focus,.application .application-additional input[type=text]:focus,.eeo-survey .application-additional input[type=text]:focus,.application .application-question input[type=email]:focus,.eeo-survey .application-question input[type=email]:focus,.application .application-additional input[type=email]:focus,.eeo-survey .application-additional input[type=email]:focus,.application .application-question input[type=tel]:focus,.eeo-survey .application-question input[type=tel]:focus,.application .application-additional input[type=tel]:focus,.eeo-survey .application-additional input[type=tel]:focus,.application .application-question textarea:focus,.eeo-survey .application-question textarea:focus,.application .application-additional textarea:focus,.eeo-survey .application-additional textarea:focus,.application .application-question select:focus,.eeo-survey .application-question select:focus,.application .application-additional select:focus,.eeo-survey .application-additional select:focus {outline: none;}.application .application-question input.location-input,.eeo-survey .application-question input.location-input,.application .application-additional input.location-input,.eeo-survey .application-additional input.location-input {margin-bottom: 0;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload,.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {width: 230px;height: 40px;}.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .visible-resume-upload .icon,.eeo-survey .application-question .visible-resume-upload .icon,.application .application-additional .visible-resume-upload .icon,.eeo-survey .application-additional .visible-resume-upload .icon {position: absolute;}.application .application-question .visible-resume-upload .resume-upload-name,.eeo-survey .application-question .visible-resume-upload .resume-upload-name,.application .application-additional .visible-resume-upload .resume-upload-name,.eeo-survey .application-additional .visible-resume-upload .resume-upload-name {vertical-align: middle;display: inline-block;line-height: 40px;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;margin-left: 24px;margin-bottom: 3px;}.application .application-question .resume-upload-filename,.eeo-survey .application-question .resume-upload-filename,.application .application-additional .resume-upload-filename,.eeo-survey .application-additional .resume-upload-filename {margin: 8px 0px;display: inline-block;font-size: 14px;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload {position: absolute;top: 0px;left: 0px;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);cursor: pointer;}.application .application-question input.invisible-resume-upload:hover,.eeo-survey .application-question input.invisible-resume-upload:hover,.application .application-additional input.invisible-resume-upload:hover,.eeo-survey .application-additional input.invisible-resume-upload:hover {border-color: #f00;}.application .application-question .linkedin-auth-button,.eeo-survey .application-question .linkedin-auth-button,.application .application-additional .linkedin-auth-button,.eeo-survey .application-additional .linkedin-auth-button {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .linkedin-auth-button.added,.eeo-survey .application-question .linkedin-auth-button.added,.application .application-additional .linkedin-auth-button.added,.eeo-survey .application-additional .linkedin-auth-button.added {background: #dadbdf;}.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea {padding-top: 10px;resize: vertical;width: 100%;height: 130px;}.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-question .dropdown-container,.eeo-survey .application-question .dropdown-container,.application .application-additional .dropdown-container,.eeo-survey .application-additional .dropdown-container {display: none;z-index: 1;overflow-y: auto;position: absolute;max-height: 200px;font-size: 14px;font-family: Meta;letter-spacing: 1px;}.application .application-question .dropdown-loading-results,.eeo-survey .application-question .dropdown-loading-results,.application .application-additional .dropdown-loading-results,.eeo-survey .application-additional .dropdown-loading-results {display: none;}.application .application-question .dropdown-no-results,.eeo-survey .application-question .dropdown-no-results,.application .application-additional .dropdown-no-results,.eeo-survey .application-additional .dropdown-no-results {display: none;}.application .application-question .dropdown-location:hover,.eeo-survey .application-question .dropdown-location:hover,.application .application-additional .dropdown-location:hover,.eeo-survey .application-additional .dropdown-location:hover,.application .application-question .dropdown-location-active,.eeo-survey .application-question .dropdown-location-active,.application .application-additional .dropdown-location-active,.eeo-survey .application-additional .dropdown-location-active {background-color: #000;}.application .required,.eeo-survey .required {display: inline-block;color: #ff794f;margin-left: 4px;font-size: 9px;padding-bottom: 0px;position: absolute;}.application .error-message,.eeo-survey .error-message {background: #ff794f;color: #fff;border-radius: 3px;padding: 5px 15px;width: 700px;max-width: 100%;}.resume-upload-failure,.resume-upload-working,.resume-upload-success,.linkedin-login-success {display: none;cursor: default;position: absolute;top: 0;left: 260px;}.resume-upload-working {cursor: wait;}.resume-upload-success,.linkedin-login-success {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 1s;-webkit-animation-name: fadein;}.resume-upload-failure {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 4s;-webkit-animation-name: fadeout;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);display: none;}.resume-upload-failure .resume-upload-label {color: #ff9000;font-size: 13px;font-weight: bold;line-height: 1.8;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);width: 250px;}.resume-upload-oversize {position: relative;display: none;}.resume-upload-label,.linkedin-login-label {position: absolute;line-height: 40px;display: inline-block;height: 40px;margin-left: 15px;width: 230px;}.loading-indicator {display: inline-block;opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);border-radius: 40px;-webkit-animation: loading 1.5s infinite linear;-moz-animation: loading 1.5s infinite linear;-o-animation: loading 1.5s infinite linear;-ms-animation: loading 1.5s infinite linear;animation: loading 1.5s infinite linear;border: 6px solid #00a1dc;border-top: 6px solid rgba(0,0,0,0);border-left: 6px solid rgba(0,0,0,0);width: 40px;height: 40px;}.loading-indicator.completed {border-left: 6px solid #515357;border-right: 6px solid #515357;border-top: 6px solid #515357;border-bottom: 6px solid #515357;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;text-align: center;}.loading-indicator .icon-checkmark {vertical-align: middle;}.loading-indicator .icon-checkmark >path {fill: #515357;}.application-form h4 {margin: 40px 0;}.awli-button-container {display: inline-block;overflow: hidden;position: relative;vertical-align: middle;}.awli-button-container .iframe-mask {position: absolute;left: 0;background-color: #f9f9f9;z-index: 1;}.awli-button-container .iframe-mask.disclaimer-mask {top: -50px;width: 243px;height: 40px;}.awli-button-container .iframe-mask.button-mask {pointer-events: none;width: 243px;height: 100%;}.awli-button,.awli-button:active,.awli-button:focus {position: relative;margin-right: 15px;padding-left: 41px;padding-right: 0;width: 243px;background: #0073b1;border-color: #0073b1;color: #fff;z-index: 10;outline: none;}.awli-button.button-masked,.awli-button:active.button-masked,.awli-button:focus.button-masked {pointer-events: none;}.awli-button.button-masked > div,.awli-button:active.button-masked > div,.awli-button:focus.button-masked > div {pointer-events: none;}.awli-button.button-masked > div > *,.awli-button:active.button-masked > div > *,.awli-button:focus.button-masked > div > * {pointer-events: none;}.awli-button.state-loading > .loading,.awli-button:active.state-loading > .loading,.awli-button:focus.state-loading > .loading {display: block;}.awli-button.state-loading > .ready,.awli-button:active.state-loading > .ready,.awli-button:focus.state-loading > .ready {display: none;}.awli-button.state-loading > .completed,.awli-button:active.state-loading > .completed,.awli-button:focus.state-loading > .completed {display: none;}.awli-button.state-ready > .loading,.awli-button:active.state-ready > .loading,.awli-button:focus.state-ready > .loading {display: none;}.awli-button.state-ready > .ready,.awli-button:active.state-ready > .ready,.awli-button:focus.state-ready > .ready {display: block;}.awli-button.state-ready > .completed,.awli-button:active.state-ready > .completed,.awli-button:focus.state-ready > .completed {display: none;}.awli-button.state-completed > .loading,.awli-button:active.state-completed > .loading,.awli-button:focus.state-completed > .loading {display: none;}.awli-button.state-completed > .ready,.awli-button:active.state-completed > .ready,.awli-button:focus.state-completed > .ready {display: none;}.awli-button.state-completed > .completed,.awli-button:active.state-completed > .completed,.awli-button:focus.state-completed > .completed {display: block;}.awli-button .icon-checkmark path:first-child,.awli-button:active .icon-checkmark path:first-child,.awli-button:focus .icon-checkmark path:first-child {fill: #fff;}.awli-button .icon-linkedin .icon-li-background,.awli-button:active .icon-linkedin .icon-li-background,.awli-button:focus .icon-linkedin .icon-li-background {fill: currentColor;}.awli-button .icon-linkedin .icon-li-text,.awli-button:active .icon-linkedin .icon-li-text,.awli-button:focus .icon-linkedin .icon-li-text {fill: #0073b1;}.awli-button:hover,.awli-button:active:hover,.awli-button:focus:hover {background: #006299;border-color: #006299;color: #fff;outline: none;}.awli-button:hover.state-loading,.awli-button:active:hover.state-loading,.awli-button:focus:hover.state-loading,.awli-button:hover.state-completed,.awli-button:active:hover.state-completed,.awli-button:focus:hover.state-completed {background: #006299;border-color: #006299;color: #fff;}.awli-button:hover.state-loading .icon-checkmark path:first-child,.awli-button:active:hover.state-loading .icon-checkmark path:first-child,.awli-button:focus:hover.state-loading .icon-checkmark path:first-child,.awli-button:hover.state-completed .icon-checkmark path:first-child,.awli-button:active:hover.state-completed .icon-checkmark path:first-child,.awli-button:focus:hover.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button.state-loading,.awli-button:active.state-loading,.awli-button:focus.state-loading,.awli-button.state-completed,.awli-button:active.state-completed,.awli-button:focus.state-completed {background: #0073b1;border-color: #0073b1;color: #fff;}.awli-button.state-loading .icon-checkmark path:first-child,.awli-button:active.state-loading .icon-checkmark path:first-child,.awli-button:focus.state-loading .icon-checkmark path:first-child,.awli-button.state-completed .icon-checkmark path:first-child,.awli-button:active.state-completed .icon-checkmark path:first-child,.awli-button:focus.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button-label {line-height: 1.33;display: block;overflow: hidden;text-align: left;}.awli-disclaimer {color: #969799;font-size: 12px;line-height: 14px;display: inline-block;padding: 10px 0;margin: 0;vertical-align: middle;}.awli-disclaimer a,.awli-disclaimer a:active,.awli-disclaimer a:focus {color: #707173;}.awli-disclaimer a:hover {color: #969799;}.IN-Awli-widget,.IN-widget {display: inline-block;position: absolute;z-index: 0;}.IN-Awli-widget.IN-Awli-widget,.IN-widget.IN-Awli-widget {left: 2px;top: -37px;}.IN-Awli-widget.IN-widget,.IN-widget.IN-widget {left: 4px;top: 7px;}.h-captcha-spacing {width: 304px;height: 78px;}.eeo-light-text {color: #555659;}h5.eeo-paragraph-heading {font-weight: bold;margin-top: 17.5px;}h5.eeo-paragraph-heading + p {margin-top: 0;}hr {border: 1px solid #e3e4e6;}.application .eeo-option-text.application-answer-alternative {margin-bottom: 0;}.eeo-option-description {color: #555659;font-size: 12px;}.eeo-three-col-list {-webkit-column-width: 233.33333333333334px;-moz-column-width: 233.33333333333334px;column-width: 233.33333333333334px;}.eeo-three-col-list > li {margin-left: 30px;}.eeo-more-info-button {display: inline-block;margin-left: 10px;vertical-align: middle;}.eeo-more-info-button > .icon-info > path {fill: #969799;}.eeo-more-info-button:hover > .icon-info > path {fill: #555659;}.eeo-expandable-description > li {margin-bottom: 10px;}li.select2-results__option.select2-results__option--highlighted .posting-option .posting-tags {color: #fff;}.posting-option {display: block;}.posting-option .posting-tags {display: block;line-height: 1em;font-size: 0.6em;color: #939393;}.posting-option .posting-tag {padding-right: 3px;}.posting-option .posting-title {text-align: left;}@-moz-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@media screen and (min-width: 800px) {.application .application-label,.eeo-survey .application-label,.application .application-field,.eeo-survey .application-field {display: inline-block;}.application .application-label,.eeo-survey .application-label {width: 210px;}.application .application-label.full-width,.eeo-survey .application-label.full-width {width: 100%;}.application .application-field,.eeo-survey .application-field {margin-left: 15px;width: 489px;}.application .application-field.full-width,.eeo-survey .application-field.full-width {padding-left: 0;width: 100%;}}.list .agency-header {font-size: 30px;}.list .agency-sub-header {color: #808080;}.list .postings-list-logo {max-width: 400px;max-height: 50px;}.list .postings-list-logo,.list .postings-list-title {display: inline-block;position: relative;min-height: 50px;float: left;}.list .postings-list-title {margin: 13px 0px 13px 0px;}.list .postings-list-logo {margin-right: 20px;}.list .filter-by-label {margin-right: 16px;}.list .filter-bar {line-height: 40px;max-width: 100%;}.list .filter-bar > div:last-of-type {margin-right: 0;}.list .filter-button-wrapper-margin-right {margin-right: 16px;}.list .filter-button-wrapper {display: inline-block;max-width: 100%;outline: none;position: relative;}.list .filter-button-wrapper:focus .filter-button {border-color: #0c92f3;}.list .filter-button-wrapper:active .filter-button {border-color: #dcdcdc;}.list .filter-button-wrapper .filter-button {color: #555659;max-width: 100%;overflow: hidden;padding: 5px 15px;padding-right: 41px;position: relative;-o-text-overflow: ellipsis;text-overflow: ellipsis;}.list .filter-button-wrapper .filter-button.has-selected-filter {color: #555659;font-weight: bold;}.list .filter-button-wrapper .filter-button .filter-button-caret {position: absolute;left: auto;left: initial;right: 15px;vertical-align: middle;}.list .filter-button-wrapper .filter-button.filter-button-mlp {padding: 8px 16px;width: 173px;font-size: 12px;text-align: left;}.list .filter-popup {position: absolute;top: 110%;left: -1px;border: 1px solid #dcdcdc;border-radius: 3px;display: none;font-size: 14px;line-height: 1;max-height: 300px;overflow-y: hidden;overflow-y: auto;text-align: left;white-space: nowrap;z-index: 1;}.list .filter-popup::-webkit-scrollbar {width: 10px;}.list .filter-popup::-webkit-scrollbar-track {background-color: #fff;}.list .filter-popup::-webkit-scrollbar-track:hover {background-color: #f9f9f9;}.list .filter-popup::-webkit-scrollbar-thumb {background-color: #d7d7d9;border: 1px solid #fff;}.list .filter-popup::-webkit-scrollbar-thumb:hover {background-color: #b1b1b3;border-color: #f9f9f9;}.list .filter-popup ul {list-style-type: none;}.list .filter-popup > ul {background: #fff;padding: 8px 0;}.list .filter-popup .group-link,.list .filter-popup .category-link {display: block;padding: 8px 32px;position: relative;}.list .filter-popup .group-link:hover,.list .filter-popup .category-link:hover {background: #f9f9f9;}.list .filter-popup .group-link:focus,.list .filter-popup .category-link:focus {background: #f3faff;outline: none;}.list .filter-popup .group-link .selected-filter-checkmark,.list .filter-popup .category-link .selected-filter-checkmark {position: absolute;left: 8px;}.list .filter-popup .group-link .selected-filter-checkmark > path,.list .filter-popup .category-link .selected-filter-checkmark > path {fill: #0c92f3;}.list .filter-popup .group-link {font-size: 16px;font-weight: bold;}.list .filter-popup .group-item {border-top: 1px solid #e3e4e6;padding: 8px 0;}.list .filter-popup .group-item:first-of-type {border-top: none;padding-top: 0;}.list .filter-popup .group-item:last-of-type {padding-bottom: 0;}.list .no-postings-message {margin-top: 80px;text-align: center;}.list .postings-group {margin: 40px 0px;}.list .horizontal-line {margin-left: 0px;}.list .posting {display: inline-block;position: relative;width: 100%;margin: 10px 0;}.list .posting .posting-apply {position: absolute;top: 0px;right: 0px;height: 40px;text-align: right;}.list .posting .posting-apply a {min-width: 100px;}.list .posting .posting-title:hover h5 {color: #579eee;}.list .posting .agency-posting-title h5 {margin-right: 230px;}.list .posting .posting-categories {height: 30px;vertical-align: top;}.list .posting .posting-category {display: inline-block;margin-right: 15px;}.show .section p {white-space: pre-wrap;}.show .posting-header {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;}.show .posting-header .posting-headline .posting-category {display: inline-block;margin-right: 10px;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-top: 10px;}@media screen and (min-width: 650px) {.show .posting-header .posting-headline {display: table-cell;width: 100%;}.show .posting-header .postings-btn-wrapper {display: table-cell;vertical-align: top;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-left: 30px;}}@media screen and (max-width: 649px) {.show .posting-header {text-align: center;padding-bottom: 40px;}}@media screen and (max-width: 480px) {.show .postings-btn {width: 100%;}}@media print {.postings-btn {display: none !important;}}.page-centered.section.last-section-apply {text-align: center;margin-bottom: 80px;}.page-centered.section.last-section-apply .btn {display: inline-block;}.page-centered.section.last-section-apply .template-btn-submit {margin: 17.5px 0px;}</style></head><body class="list header-compact"><div class="page list"><div class="main-header page-full-width section-wrapper"><div class="main-header-content page-centered narrow-section page-full-width"><a href="https://jobs.lever.co/GoToGroup" class="main-header-logo"><img alt="GoTo Group logo" src="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1682066441676.png"></a></div></div></div><div class="content-wrapper list-page"><div class="content"><div class="section-wrapper page-full-width"><div class="section page-centered"><div class="filter-bar"><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?workplaceType=onsite" rel="nofollow">On-site</a></li><li><a class="category-link" href="?workplaceType=hybrid" rel="nofollow">Hybrid</a></li><li><a class="category-link" href="?workplaceType=remote" rel="nofollow">Remote</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?location=Bali" rel="nofollow">Bali</a></li><li><a class="category-link" href="?location=Balikpapan" rel="nofollow">Balikpapan</a></li><li><a class="category-link" href="?location=Bandung" rel="nofollow">Bandung</a></li><li><a class="category-link" href="?location=Bengaluru" rel="nofollow">Bengaluru</a></li><li><a class="category-link" href="?location=Bogor" rel="nofollow">Bogor</a></li><li><a class="category-link" href="?location=Depok" rel="nofollow">Depok</a></li><li><a class="category-link" href="?location=Gurugram" rel="nofollow">Gurugram</a></li><li><a class="category-link" href="?location=Hanoi" rel="nofollow">Hanoi</a></li><li><a class="category-link" href="?location=Ho%20Chi%20Minh%20City" rel="nofollow">Ho Chi Minh City</a></li><li><a class="category-link" href="?location=Jakarta" rel="nofollow">Jakarta</a></li><li><a class="category-link" href="?location=Malang" rel="nofollow">Malang</a></li><li><a class="category-link" href="?location=Singapore" rel="nofollow">Singapore</a></li><li><a class="category-link" href="?location=Tangerang" rel="nofollow">Tangerang</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Team: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Team<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li class="group-item"><a class="group-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li class="group-item" role="group" aria-label="FinTech - CISO"><a class="group-link" href="?department=FinTech%20-%20CISO" rel="nofollow">FinTech - CISO</a><ul><li><a class="category-link" href="?department=FinTech%20-%20CISO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Consumer Lending"><a class="group-link" href="?department=FinTech%20-%20Consumer%20Lending" rel="nofollow">FinTech - Consumer Lending</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=Gojek%20GoPay" rel="nofollow">Gojek GoPay</a></li></ul></li><li class="group-item" role="group" aria-label="Fintech - Consumer Payments"><a class="group-link" href="?department=Fintech%20-%20Consumer%20Payments" rel="nofollow">Fintech - Consumer Payments</a><ul><li><a class="category-link" href="?department=Fintech%20-%20Consumer%20Payments&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=Fintech%20-%20Consumer%20Payments&amp;team=Consumer%20Experience" rel="nofollow">Consumer Experience</a></li><li><a class="category-link" href="?department=Fintech%20-%20Consumer%20Payments&amp;team=Payment%20Core" rel="nofollow">Payment Core</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Data Products &amp; Infra"><a class="group-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra" rel="nofollow">FinTech - Data Products &amp; Infra</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Finance"><a class="group-link" href="?department=FinTech%20-%20Finance" rel="nofollow">FinTech - Finance</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Finance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Legal"><a class="group-link" href="?department=FinTech%20-%20Legal" rel="nofollow">FinTech - Legal</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Legal&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Merchant Services"><a class="group-link" href="?department=FinTech%20-%20Merchant%20Services" rel="nofollow">FinTech - Merchant Services</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Offline%20Merchants" rel="nofollow">Offline Merchants</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Online%20Merchants" rel="nofollow">Online Merchants</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - People &amp; Culture"><a class="group-link" href="?department=FinTech%20-%20People%20%26%20Culture" rel="nofollow">FinTech - People &amp; Culture</a><ul><li><a class="category-link" href="?department=FinTech%20-%20People%20%26%20Culture&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - COO Office"><a class="group-link" href="?department=HoldCo%20-%20COO%20Office" rel="nofollow">HoldCo - COO Office</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20COO%20Office&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Enterprise Risk Management"><a class="group-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management" rel="nofollow">HoldCo - Enterprise Risk Management</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Finance"><a class="group-link" href="?department=HoldCo%20-%20Finance" rel="nofollow">HoldCo - Finance</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Finance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - People &amp; Culture"><a class="group-link" href="?department=HoldCo%20-%20People%20%26%20Culture" rel="nofollow">HoldCo - People &amp; Culture</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20People%20%26%20Culture&amp;team=HR%20Information%20Systems" rel="nofollow">HR Information Systems</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Ads"><a class="group-link" href="?department=ODS%20-%20Ads" rel="nofollow">ODS - Ads</a><ul><li><a class="category-link" href="?department=ODS%20-%20Ads&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Consumer Platform"><a class="group-link" href="?department=ODS%20-%20Consumer%20Platform" rel="nofollow">ODS - Consumer Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Consumer%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Engineering Platform"><a class="group-link" href="?department=ODS%20-%20Engineering%20Platform" rel="nofollow">ODS - Engineering Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Engineering%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Finance"><a class="group-link" href="?department=ODS%20-%20Finance" rel="nofollow">ODS - Finance</a><ul><li><a class="category-link" href="?department=ODS%20-%20Finance&amp;team=Accounting" rel="nofollow">Accounting</a></li><li><a class="category-link" href="?department=ODS%20-%20Finance&amp;team=FP%26A" rel="nofollow">FP&amp;A</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Food"><a class="group-link" href="?department=ODS%20-%20Food" rel="nofollow">ODS - Food</a><ul><li><a class="category-link" href="?department=ODS%20-%20Food&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Groceries"><a class="group-link" href="?department=ODS%20-%20Groceries" rel="nofollow">ODS - Groceries</a><ul><li><a class="category-link" href="?department=ODS%20-%20Groceries&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Platform Mobility, Care &amp; Comms"><a class="group-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms" rel="nofollow">ODS - Platform Mobility, Care &amp; Comms</a><ul><li><a class="category-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Public Policy &amp; Government Relations"><a class="group-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations" rel="nofollow">ODS - Public Policy &amp; Government Relations</a><ul><li><a class="category-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Regions"><a class="group-link" href="?department=ODS%20-%20Regions" rel="nofollow">ODS - Regions</a><ul><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=East%20Java%2C%20Bali%2C%20Nusra%20Regions" rel="nofollow">East Java, Bali, Nusra Regions</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Emerging%20Market" rel="nofollow">Emerging Market</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Sales"><a class="group-link" href="?department=ODS%20-%20Sales" rel="nofollow">ODS - Sales</a><ul><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=Sales%20Excellence" rel="nofollow">Sales Excellence</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Customer Relationship Management"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management" rel="nofollow">ODS - Shared Service, Customer Relationship Management</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Design"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Design" rel="nofollow">ODS - Shared Service, Design</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Design&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Marketing"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing" rel="nofollow">ODS - Shared Service, Marketing</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Technology"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology" rel="nofollow">ODS - Shared Service, Technology</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport"><a class="group-link" href="?department=ODS%20-%20Transport" rel="nofollow">ODS - Transport</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport &amp; Mobility"><a class="group-link" href="?department=ODS%20-%20Transport%20%26%20Mobility" rel="nofollow">ODS - Transport &amp; Mobility</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport%20%26%20Mobility&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="Other teams"><a class="group-link" href="?department=" rel="nofollow">Other teams</a><ul><li><a class="category-link" href="?department=&amp;team=" rel="nofollow">Uncategorized</a></li></ul></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Work type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Work type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?commitment=Direct%20Contract" rel="nofollow">Direct Contract</a></li><li><a class="category-link" href="?commitment=Internship" rel="nofollow">Internship</a></li><li><a class="category-link" href="?commitment=Permanent" rel="nofollow">Permanent</a></li><li><a class="category-link" href="?commitment=" rel="nofollow">Uncategorized</a></li></ul></div></div><noscript><style type="text/css">.filter-button-wrapper:focus {outline: none;}.filter-button-wrapper .filter-popup {top: 100%;}.filter-button-wrapper:focus .filter-popup,.filter-button-wrapper:hover .filter-popup,.filter-button-wrapper:active .filter-popup {display: block;}</style></noscript></div><div class="postings-wrapper"><div class="postings-group"><div class="large-category-header">FinTech - CISO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="36caef5f-7a1c-4326-80b4-8c146060ac70"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70"><h5 data-qa="posting-name">IT GRC Senior Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Consumer Lending</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="d25e2655-a6d3-4ff9-a818-38ac5b7b609a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d25e2655-a6d3-4ff9-a818-38ac5b7b609a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d25e2655-a6d3-4ff9-a818-38ac5b7b609a"><h5 data-qa="posting-name">Customer Engagement Lead (Telesales) - Consumer Lending - #10073</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a3543985-6d2c-45cf-84f7-312ec7efed36"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36"><h5 data-qa="posting-name">Full Stack Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="424140f5-5064-4ce2-8c4d-2b7ecbb14d51"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/424140f5-5064-4ce2-8c4d-2b7ecbb14d51" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/424140f5-5064-4ce2-8c4d-2b7ecbb14d51"><h5 data-qa="posting-name">Gopay Later Growth Senior Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6dc20c4e-4d40-4f57-a138-4776013e454e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e"><h5 data-qa="posting-name">Head of Operation - Consumer Lending - #10162</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="44117b68-3ece-40ac-91c1-920caadfe5dd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd"><h5 data-qa="posting-name">Principal Data Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="5611e062-e094-4da3-ab1c-75c85cf62194"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194"><h5 data-qa="posting-name">Risk Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e318ec15-ebfb-44d7-a6f0-c1d1b3cc9e59"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e318ec15-ebfb-44d7-a6f0-c1d1b3cc9e59" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e318ec15-ebfb-44d7-a6f0-c1d1b3cc9e59"><h5 data-qa="posting-name">Risk Strategy - Consumer Lending #9919</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e33b73ae-63e2-4e9c-aff9-03e9127e4e4e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e33b73ae-63e2-4e9c-aff9-03e9127e4e4e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e33b73ae-63e2-4e9c-aff9-03e9127e4e4e"><h5 data-qa="posting-name">Risk Strategy - Consumer Lending #9919</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="472ae629-87cb-4f8c-bb69-eae35cf3751e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e"><h5 data-qa="posting-name">SDET - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><h5 data-qa="posting-name">Senior Data Analyst (Analytics Engineer)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><h5 data-qa="posting-name">Senior Software Engineer (Backend) - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="88358de8-e37b-4bd6-9afe-359eea3128b9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9"><h5 data-qa="posting-name">Senior Software Engineer (Full Stack) - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><h5 data-qa="posting-name">Site Reliability Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="afb5bc40-aa4f-4837-a2d9-7d38eade2599"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599"><h5 data-qa="posting-name">Strategy Senior Manager, Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="17408b81-f5a0-4f15-afae-cc04ed7e43b6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6"><h5 data-qa="posting-name">Underwriting and Credit Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Gojek GoPay</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ac34e3be-5747-4371-ad39-4b61d62302ce"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ac34e3be-5747-4371-ad39-4b61d62302ce" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ac34e3be-5747-4371-ad39-4b61d62302ce"><h5 data-qa="posting-name">Growth Lead - GoPay Later</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">Fintech - Consumer Payments</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4d916963-ca3f-406b-be57-a79e2e226904"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4d916963-ca3f-406b-be57-a79e2e226904" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4d916963-ca3f-406b-be57-a79e2e226904"><h5 data-qa="posting-name">Lead Product Manager - Consumer Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Consumer Experience</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="00c9bdb6-623b-4604-8d87-aa0496bfc30e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/00c9bdb6-623b-4604-8d87-aa0496bfc30e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/00c9bdb6-623b-4604-8d87-aa0496bfc30e"><h5 data-qa="posting-name">Growth Analyst - Consumer Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="0169bd4d-f352-4162-8e8e-2c09df5b8db4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4"><h5 data-qa="posting-name">SDET - Growth (Bangalore)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="7b320e00-3745-4478-8097-93405566819d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7b320e00-3745-4478-8097-93405566819d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7b320e00-3745-4478-8097-93405566819d"><h5 data-qa="posting-name">SDET - Growth (Jakarta)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Payment Core</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="2185e0b2-1f04-4aef-b83b-42f6fc2b44d0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2185e0b2-1f04-4aef-b83b-42f6fc2b44d0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2185e0b2-1f04-4aef-b83b-42f6fc2b44d0"><h5 data-qa="posting-name">SDET - Payments Tooling (Bangalore)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="a4510adc-edf8-4bb4-bf25-3315f61f112d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a4510adc-edf8-4bb4-bf25-3315f61f112d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a4510adc-edf8-4bb4-bf25-3315f61f112d"><h5 data-qa="posting-name">Senior SDET - Merchant Gateway</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e8141985-a154-462d-b218-e386f9d27364"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e8141985-a154-462d-b218-e386f9d27364" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e8141985-a154-462d-b218-e386f9d27364"><h5 data-qa="posting-name">Senior SDET - Mobile Application (Gojek &amp; Gopay)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="076bd021-0157-42a4-89fd-51d9f236e490"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490"><h5 data-qa="posting-name">Senior SDET - Payment Widget &amp; Vendor Gateway</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Data Products &amp; Infra</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="6be8c0fe-d1e1-416f-8b8c-19d792255ff4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6be8c0fe-d1e1-416f-8b8c-19d792255ff4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6be8c0fe-d1e1-416f-8b8c-19d792255ff4"><h5 data-qa="posting-name">Data Warehouse Engineer - Payments Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c3a0c7d8-a6e7-45a0-af1a-1eb5b6e18fc5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c3a0c7d8-a6e7-45a0-af1a-1eb5b6e18fc5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c3a0c7d8-a6e7-45a0-af1a-1eb5b6e18fc5"><h5 data-qa="posting-name">Lead Software Engineer - Payments Data Products &amp; Infra</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="60d37414-287e-4552-a0d0-accf1737d0ce"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce"><h5 data-qa="posting-name">Risk Analyst - Payments #9984</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a61cda6c-82fd-4daf-aabf-3db91e01684f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f"><h5 data-qa="posting-name">Risk Manager - Payments #9868</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><h5 data-qa="posting-name">Senior Data Engineering - Data Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="a539cdc1-109f-48e8-9b24-1a831b735f01"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01"><h5 data-qa="posting-name">Senior Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="10dbc666-80f8-4250-85ee-59fa92d056aa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa"><h5 data-qa="posting-name">Senior Software Engineer (Data Platform) - Payments Data Products &amp; Infra</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="60283bc5-9f60-400a-8289-bcbe332fbc09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09"><h5 data-qa="posting-name">Cost Management Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Legal</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="365ef8c5-c4b7-4aab-9d0d-eabea5ef448b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/365ef8c5-c4b7-4aab-9d0d-eabea5ef448b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/365ef8c5-c4b7-4aab-9d0d-eabea5ef448b"><h5 data-qa="posting-name">AML/CFT Manager - Fintech - MAB</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da40c805-1fbd-4228-8059-b7729041021e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da40c805-1fbd-4228-8059-b7729041021e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da40c805-1fbd-4228-8059-b7729041021e"><h5 data-qa="posting-name">FinServ Compliance Manager - #9918</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="19489ced-76de-411a-8205-8aebdef22d4c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/19489ced-76de-411a-8205-8aebdef22d4c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/19489ced-76de-411a-8205-8aebdef22d4c"><h5 data-qa="posting-name">Payments Compliance Manager - #9917</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Merchant Services</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="761415aa-89b7-4ffb-a19b-2b91ac4243b4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4"><h5 data-qa="posting-name">Growth Lead (Merchant Lending)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="70493d8a-7d7f-4660-b1ed-c792d0d765be"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be"><h5 data-qa="posting-name">Head of Sales - Midtrans - #9618</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><h5 data-qa="posting-name">Key Account Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="3f4f687f-8599-4d5c-96d5-8af234c3b09d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d"><h5 data-qa="posting-name">Onboarding &amp; Support Business Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="fc7c3413-6c4f-42bd-a048-70387bd490a4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4"><h5 data-qa="posting-name">Operations Support Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="60b17958-bbef-411b-9024-5cbbabf12fff"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60b17958-bbef-411b-9024-5cbbabf12fff" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60b17958-bbef-411b-9024-5cbbabf12fff"><h5 data-qa="posting-name">Senior Sales Manager - Midtrans - #9679</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Offline Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="bc0944ec-775a-4a20-a55e-df5ddbbf4ff8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bc0944ec-775a-4a20-a55e-df5ddbbf4ff8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bc0944ec-775a-4a20-a55e-df5ddbbf4ff8"><h5 data-qa="posting-name">Digital Marketing Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><h5 data-qa="posting-name">Product Design Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9377622b-e5b4-4cd1-a5b0-8432c9ef5808"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9377622b-e5b4-4cd1-a5b0-8432c9ef5808" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9377622b-e5b4-4cd1-a5b0-8432c9ef5808"><h5 data-qa="posting-name">Sales Support Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="50c8a826-2076-40a3-a829-b96b29c9647f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f"><h5 data-qa="posting-name">Senior Product Marketing Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Online Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="989a85d6-22b2-4e17-8298-945e97247331"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/989a85d6-22b2-4e17-8298-945e97247331" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/989a85d6-22b2-4e17-8298-945e97247331"><h5 data-qa="posting-name">Senior Frontend Engineer - Online Merchant</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - People &amp; Culture</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="188afe61-267f-4de2-914d-af8177627902"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/188afe61-267f-4de2-914d-af8177627902" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/188afe61-267f-4de2-914d-af8177627902"><h5 data-qa="posting-name">People Business Partner &amp; Employee Relations Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - COO Office</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="2242125a-7155-4353-bc79-473d237d6808"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808"><h5 data-qa="posting-name">Business Intelligence Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6d8ebb73-2348-423d-847e-b8a8408ac1ed"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed"><h5 data-qa="posting-name">Data Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="36d71dff-c9ac-44b8-b870-f74d941bd7d3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3"><h5 data-qa="posting-name">Data Engineer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="73e71b86-d53f-4841-92ec-4bd09a0ef479"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479"><h5 data-qa="posting-name">Senior Data Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2c5a98c2-e5f9-4fbf-a710-9ac6ca9a561a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2c5a98c2-e5f9-4fbf-a710-9ac6ca9a561a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2c5a98c2-e5f9-4fbf-a710-9ac6ca9a561a"><h5 data-qa="posting-name">Transformation Office Manager - #10098</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Enterprise Risk Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><h5 data-qa="posting-name">Head of Business Continuity Management</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="56966262-038f-497f-84c1-f360a9440c55"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55"><h5 data-qa="posting-name">Assistant Tax Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a209e959-6eaf-4d0e-807a-42dcaffbaf91"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a209e959-6eaf-4d0e-807a-42dcaffbaf91" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a209e959-6eaf-4d0e-807a-42dcaffbaf91"><h5 data-qa="posting-name">Senior Transfer Pricing</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - People &amp; Culture</div><div class="posting-category-title large-category-label">HR Information Systems</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8fe35112-8410-4cf3-9a50-4c7287e95b57"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57"><h5 data-qa="posting-name">People Systems Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta / Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Ads</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="eaab5bee-084d-4cdc-bd08-63230251009c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c"><h5 data-qa="posting-name">Supply Strategy Data Analyst [Ads]</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Consumer Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="86673189-b5e2-4ace-b1a3-5ab20f14d84d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d"><h5 data-qa="posting-name">Senior Data Scientist (India)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="c54483cb-dd68-43c3-9fe5-623dbb6db56f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c54483cb-dd68-43c3-9fe5-623dbb6db56f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c54483cb-dd68-43c3-9fe5-623dbb6db56f"><h5 data-qa="posting-name">Senior Principal Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="cd554abc-dc06-4177-be50-ccbc638fd6d9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9"><h5 data-qa="posting-name">Software Engineer - Customer Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Engineering Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="d3060482-4566-44a1-8f48-5d05dde1ad63"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d3060482-4566-44a1-8f48-5d05dde1ad63" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d3060482-4566-44a1-8f48-5d05dde1ad63"><h5 data-qa="posting-name">Associate Software Engineer - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="dfe98505-36d8-4467-aa36-df8599ab69d8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8"><h5 data-qa="posting-name">Engineering Manager - Data Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><h5 data-qa="posting-name">Lead Software Engineer - Observability</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><h5 data-qa="posting-name">Senior Android Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><h5 data-qa="posting-name">Senior Data Warehouse Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2b430ba4-210e-4db6-a63e-c11459a0304f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f"><h5 data-qa="posting-name">Senior Data Warehouse Engineer - India</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><h5 data-qa="posting-name">Senior Database Administrator Engineer - Engineering Platform (Gurgaon)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="28fe323b-ed5f-482b-b71d-ed60662bed8b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b"><h5 data-qa="posting-name">Senior DevOps Engineer - Engineering Platform (Gurgaon)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="68f907a3-329f-411b-af2d-a66b38243919"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919"><h5 data-qa="posting-name">Senior Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="3c6bca98-cc50-43be-bafd-46ea1ab35594"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3c6bca98-cc50-43be-bafd-46ea1ab35594" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3c6bca98-cc50-43be-bafd-46ea1ab35594"><h5 data-qa="posting-name">Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><h5 data-qa="posting-name">Software Engineer - Engineering Platforms</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Finance</div><div class="posting-category-title large-category-label">Accounting</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="9aa5a060-e2c3-4296-9057-049a3c1fa5bd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9aa5a060-e2c3-4296-9057-049a3c1fa5bd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9aa5a060-e2c3-4296-9057-049a3c1fa5bd"><h5 data-qa="posting-name">Accountant</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">FP&amp;A</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="111ec429-1fa8-43ef-a9bc-94ad60444ea9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/111ec429-1fa8-43ef-a9bc-94ad60444ea9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/111ec429-1fa8-43ef-a9bc-94ad60444ea9"><h5 data-qa="posting-name">FP&amp;A - Consolidation Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Food</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><h5 data-qa="posting-name">Growth Planning &amp; Operation - GoFood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><h5 data-qa="posting-name">Growth Strategy Manager - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="b1f917e0-a9a0-4a3c-a4c3-505e41c1f034"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b1f917e0-a9a0-4a3c-a4c3-505e41c1f034" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b1f917e0-a9a0-4a3c-a4c3-505e41c1f034"><h5 data-qa="posting-name">Lead Software Engineer - Gofood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="2d3aae20-ff7e-4afb-8164-a351661c1680"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680"><h5 data-qa="posting-name">Lead Software Engineer (IC) - Go-Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="e407433b-435a-4607-89bd-5faf51cf622e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e"><h5 data-qa="posting-name">Product Designer - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><h5 data-qa="posting-name">Product Manager - Growth</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9f1897da-a914-439d-9454-e40d10735858"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9f1897da-a914-439d-9454-e40d10735858" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9f1897da-a914-439d-9454-e40d10735858"><h5 data-qa="posting-name">Product Marketing Executive</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="68d7d220-1f05-49ea-9f34-fffe0ef75aea"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/68d7d220-1f05-49ea-9f34-fffe0ef75aea" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/68d7d220-1f05-49ea-9f34-fffe0ef75aea"><h5 data-qa="posting-name">Product Marketing Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="850a3da9-a054-4ef9-981d-d0c0157a18c1"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/850a3da9-a054-4ef9-981d-d0c0157a18c1" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/850a3da9-a054-4ef9-981d-d0c0157a18c1"><h5 data-qa="posting-name">Researcher - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da8d4a37-f5a4-4436-8743-58c787781285"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285"><h5 data-qa="posting-name">Senior Growth Manager - Food &amp; Ads</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="12b79ada-f0fb-456f-9aa9-0745f9aa12d2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/12b79ada-f0fb-456f-9aa9-0745f9aa12d2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/12b79ada-f0fb-456f-9aa9-0745f9aa12d2"><h5 data-qa="posting-name">Senior Researcher - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="930cfb6b-99e3-4334-bc10-3fac18f8eff0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0"><h5 data-qa="posting-name">Software Engineer (Android) - Gofood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="baf1c074-dffd-41d9-ad55-796428e4d1c8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/baf1c074-dffd-41d9-ad55-796428e4d1c8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/baf1c074-dffd-41d9-ad55-796428e4d1c8"><h5 data-qa="posting-name">Sr. Marketing Executive - Brand Campaign</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Groceries</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="2df4ac6b-ceba-41e5-a8de-42ebe6d20fa2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2df4ac6b-ceba-41e5-a8de-42ebe6d20fa2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2df4ac6b-ceba-41e5-a8de-42ebe6d20fa2"><h5 data-qa="posting-name">Strategic Partnerships Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Platform Mobility, Care &amp; Comms</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><h5 data-qa="posting-name">Product Manager - Logistic</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="50c98a4b-fda9-41ec-8e33-28f996cdc291"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/50c98a4b-fda9-41ec-8e33-28f996cdc291" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/50c98a4b-fda9-41ec-8e33-28f996cdc291"><h5 data-qa="posting-name">Researcher - Mobility</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="34f6146a-c482-407c-a31c-72ac9bb90a7c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c"><h5 data-qa="posting-name">Senior Data Scientist - Marketplace (Singapore)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Public Policy &amp; Government Relations</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><h5 data-qa="posting-name">Manager of Food &amp; Groceries Regulatory</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Regions</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4df84464-9b48-4256-b23d-021d9d7cd376"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4df84464-9b48-4256-b23d-021d9d7cd376" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4df84464-9b48-4256-b23d-021d9d7cd376"><h5 data-qa="posting-name">Account Executive (Malang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Malang</span></div></a></div><div class="posting" data-qa-posting-id="9d5d858b-0e72-41c4-8acf-fed0f7f1cf0b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9d5d858b-0e72-41c4-8acf-fed0f7f1cf0b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9d5d858b-0e72-41c4-8acf-fed0f7f1cf0b"><h5 data-qa="posting-name">Account Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8c43d5dc-1ee7-4fa1-9a41-366eea4b4caa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8c43d5dc-1ee7-4fa1-9a41-366eea4b4caa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8c43d5dc-1ee7-4fa1-9a41-366eea4b4caa"><h5 data-qa="posting-name">Account Manager - Tangerang</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="c5a0d0c2-5bcc-4ee3-ac4f-ccfc29fee0f1"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c5a0d0c2-5bcc-4ee3-ac4f-ccfc29fee0f1" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c5a0d0c2-5bcc-4ee3-ac4f-ccfc29fee0f1"><h5 data-qa="posting-name">Area CE Associate - Central Jakarta</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="95352b3a-e239-4d08-8e8a-aeedba71872e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/95352b3a-e239-4d08-8e8a-aeedba71872e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/95352b3a-e239-4d08-8e8a-aeedba71872e"><h5 data-qa="posting-name">Area Operations Manager - Bandung</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bandung</span></div></a></div><div class="posting" data-qa-posting-id="18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><h5 data-qa="posting-name">Area Operations Manager (Bogor Depok)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Depok / Bogor</span></div></a></div><div class="posting" data-qa-posting-id="69cc5000-f892-48ae-a65c-58239123d62a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/69cc5000-f892-48ae-a65c-58239123d62a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/69cc5000-f892-48ae-a65c-58239123d62a"><h5 data-qa="posting-name">Area Operations Staff (Jakarta)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><h5 data-qa="posting-name">Area Operations Staff (Tangerang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="8c7385d0-98c1-41d8-b780-6c84ed6c40ad"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8c7385d0-98c1-41d8-b780-6c84ed6c40ad" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8c7385d0-98c1-41d8-b780-6c84ed6c40ad"><h5 data-qa="posting-name">Area Sales Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="471c9704-cd3d-4cc3-9ddb-36f64cfa787b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/471c9704-cd3d-4cc3-9ddb-36f64cfa787b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/471c9704-cd3d-4cc3-9ddb-36f64cfa787b"><h5 data-qa="posting-name">Driver Strategy Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="22056898-0433-418d-9e7f-b691455edd67"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/22056898-0433-418d-9e7f-b691455edd67" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/22056898-0433-418d-9e7f-b691455edd67"><h5 data-qa="posting-name">Partnership Senior Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div><div class="posting" data-qa-posting-id="4ba1eea8-feed-4843-be2e-93a21f0eadb1"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1"><h5 data-qa="posting-name">Region Analytics Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div><div class="posting" data-qa-posting-id="ea0f2d5a-c9d5-4202-ac91-a671b128bfb4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ea0f2d5a-c9d5-4202-ac91-a671b128bfb4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ea0f2d5a-c9d5-4202-ac91-a671b128bfb4"><h5 data-qa="posting-name">Region Merchant Development Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="29c083cb-0dda-4ce1-9513-788f00e8f482"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/29c083cb-0dda-4ce1-9513-788f00e8f482" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/29c083cb-0dda-4ce1-9513-788f00e8f482"><h5 data-qa="posting-name">Region Operations Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="3377f50a-d56f-42e0-acc5-b69d405a37a9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9"><h5 data-qa="posting-name">Senior/Partnership Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">East Java, Bali, Nusra Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4220480a-be7c-4f31-8d6b-59a21558b594"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4220480a-be7c-4f31-8d6b-59a21558b594" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4220480a-be7c-4f31-8d6b-59a21558b594"><h5 data-qa="posting-name">Area Consumer Engagement Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bali</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Emerging Market</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="95ee9a06-a46d-43a2-a8e7-003de776404d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d"><h5 data-qa="posting-name">Area Operations Supervisor - Balikpapan</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Balikpapan</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Sales</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="dfa07479-8e81-43ff-a9ad-4ae02f72207e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dfa07479-8e81-43ff-a9ad-4ae02f72207e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dfa07479-8e81-43ff-a9ad-4ae02f72207e"><h5 data-qa="posting-name">Account Manager (North East Jakarta)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="582fed88-5070-4a4b-8ef2-4a9a55e43d92"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/582fed88-5070-4a4b-8ef2-4a9a55e43d92" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/582fed88-5070-4a4b-8ef2-4a9a55e43d92"><h5 data-qa="posting-name">Area Account Executive - Hanoi</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Hanoi</span></div></a></div><div class="posting" data-qa-posting-id="a5f5f567-0e95-4763-8c50-c4dcfb0b757e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a5f5f567-0e95-4763-8c50-c4dcfb0b757e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a5f5f567-0e95-4763-8c50-c4dcfb0b757e"><h5 data-qa="posting-name">Sales Strategy Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Sales Excellence</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f39be622-e287-41df-bcb2-7389478a1be4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4"><h5 data-qa="posting-name">Sales Support Senior Associate, Enterprise</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Customer Relationship Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="0489939a-c571-4d5f-adaa-95ceac8912c5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5"><h5 data-qa="posting-name">Region Operations Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><h5 data-qa="posting-name">Strategic Planner - Creative Labs - #10088</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Design</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="6aac2e66-88b7-46a3-9c91-605a33dc532d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6aac2e66-88b7-46a3-9c91-605a33dc532d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6aac2e66-88b7-46a3-9c91-605a33dc532d"><h5 data-qa="posting-name">UX Motion Designer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="ea17a902-a106-48ab-be52-08ce99f99b4b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ea17a902-a106-48ab-be52-08ce99f99b4b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ea17a902-a106-48ab-be52-08ce99f99b4b"><h5 data-qa="posting-name">UX Writer - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Marketing</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="805e2dcd-40aa-4655-85c2-380114ac8292"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/805e2dcd-40aa-4655-85c2-380114ac8292" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/805e2dcd-40aa-4655-85c2-380114ac8292"><h5 data-qa="posting-name">Creative Director</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="7d1c915f-ac53-4a2c-887a-41bbbda48a26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26"><h5 data-qa="posting-name">Graphic Designer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8d38e7a3-89eb-4d80-997d-b08404b0e1a0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8d38e7a3-89eb-4d80-997d-b08404b0e1a0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8d38e7a3-89eb-4d80-997d-b08404b0e1a0"><h5 data-qa="posting-name">Marketing Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2ef0e64a-0119-4601-9d7c-686c9301090a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2ef0e64a-0119-4601-9d7c-686c9301090a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2ef0e64a-0119-4601-9d7c-686c9301090a"><h5 data-qa="posting-name">Senior Copywriter</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><h5 data-qa="posting-name">Social Media Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Technology</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4a126665-42d6-4a36-82a5-089dca789f41"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41"><h5 data-qa="posting-name">Lead Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="a54f9d2d-4b2d-43c3-bb82-c6705beefbcf"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a54f9d2d-4b2d-43c3-bb82-c6705beefbcf" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a54f9d2d-4b2d-43c3-bb82-c6705beefbcf"><h5 data-qa="posting-name">Principal Software Engineer - Marketplace</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="426f18b4-739e-4da0-a74b-446c349c0a31"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31"><h5 data-qa="posting-name">Principal Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="4174ba7b-c2d9-4cba-a725-da3b0a4265ee"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4174ba7b-c2d9-4cba-a725-da3b0a4265ee" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4174ba7b-c2d9-4cba-a725-da3b0a4265ee"><h5 data-qa="posting-name">Product Manager - Merchant Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="376aefd9-6d6c-4e57-8040-a3b0dd416d26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="f680021a-b5cc-43ea-a048-255827353a92"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f680021a-b5cc-43ea-a048-255827353a92" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f680021a-b5cc-43ea-a048-255827353a92"><h5 data-qa="posting-name">Senior Data Analyst - India</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><h5 data-qa="posting-name">Senior SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="0216fdb3-64c6-4e37-ace8-1d9c0c79ca23"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0216fdb3-64c6-4e37-ace8-1d9c0c79ca23" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0216fdb3-64c6-4e37-ace8-1d9c0c79ca23"><h5 data-qa="posting-name">Senior Software Engineer - Event Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="8afd4278-a5a8-43f2-8718-2986433f2ddb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb"><h5 data-qa="posting-name">Senior Technical Program Manager - Engineering Platform (Bangalore)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="331177df-4294-4bc1-93a4-6459ff18ef97"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97"><h5 data-qa="posting-name">Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="16a62a49-46a3-4683-b1b1-e42e60c2c7e8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/16a62a49-46a3-4683-b1b1-e42e60c2c7e8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/16a62a49-46a3-4683-b1b1-e42e60c2c7e8"><h5 data-qa="posting-name">Software Engineer (iOS) - Gofood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9fa9af02-5e5c-4812-b98f-fba1a5041b25"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9fa9af02-5e5c-4812-b98f-fba1a5041b25" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9fa9af02-5e5c-4812-b98f-fba1a5041b25"><h5 data-qa="posting-name">Software Engineer (iOS) - Groceries</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="59548879-6e27-4764-9378-85f7f2003a91"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/59548879-6e27-4764-9378-85f7f2003a91" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/59548879-6e27-4764-9378-85f7f2003a91"><h5 data-qa="posting-name">CRM Executive (Marketing)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d93a7524-8ab9-4499-9f04-0876fcafa529"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529"><h5 data-qa="posting-name">Data Operations Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="5d07cd21-8826-4de7-9ad4-15909a0c5c37"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37"><h5 data-qa="posting-name">Digital Marketing Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="abeeede5-8126-4e1d-b4e4-c5b4afbff43c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/abeeede5-8126-4e1d-b4e4-c5b4afbff43c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/abeeede5-8126-4e1d-b4e4-c5b4afbff43c"><h5 data-qa="posting-name">Digital Performance Marketing Specialist Gojek</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c838dc08-24e8-417c-9d70-a617bc58e200"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200"><h5 data-qa="posting-name">Head of Engineering - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="6f3368c9-6e84-489c-add3-4ad1fd4b9519"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519"><h5 data-qa="posting-name">Operations Analyst, Data Operations (Trust &amp; Safety)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><h5 data-qa="posting-name">Risk Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="53c0b8a9-1a83-4c34-9a59-b5170ce54193"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193"><h5 data-qa="posting-name">Senior Software Engineer - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a161ba72-275d-4225-85c0-fac7f782b397"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a161ba72-275d-4225-85c0-fac7f782b397" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a161ba72-275d-4225-85c0-fac7f782b397"><h5 data-qa="posting-name">Software Engineer (iOS) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="22ac4805-bcbe-4698-9e51-cb25754ac244"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244"><h5 data-qa="posting-name">Sr. Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="8b9f79f1-25ac-45cd-b2a1-98a4e7217644"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8b9f79f1-25ac-45cd-b2a1-98a4e7217644" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8b9f79f1-25ac-45cd-b2a1-98a4e7217644"><h5 data-qa="posting-name">Vendor Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport &amp; Mobility</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8bf17375-6318-400f-8216-4a132071777a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a"><h5 data-qa="posting-name">Lead Product Manager, GoCorp</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Uncategorized</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ce6e4a7d-09a4-446e-b717-6232efaed996"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ce6e4a7d-09a4-446e-b717-6232efaed996" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ce6e4a7d-09a4-446e-b717-6232efaed996"><h5 data-qa="posting-name">GoTo Impact Lab Research Intern</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div></div></div></div></div></div><div class="main-footer page-full-width"><div class="main-footer-text page-centered"><p><a href="https://www.gotocompany.com/">GoTo Group Home Page</a></p><a href="https://www.lever.co/job-seeker-support/" class="image-link"><span>Jobs powered by </span><img alt="Lever logo" src="/img/lever-logo-full.svg"></a></div></div><script src="/js/bug-snag.js" data-apikey="6a247c6ff13012d02fde17377f0b857b" data-appversion="0.0.1717440470" data-endpoint="https://bugs.lever.co/js" data-releasestage="production"></script><script>var gaCode = "UA-129682534-1";</script><script>var gaAllowLinker = false;</script><script async src="https://www.googletagmanager.com/gtag/js?id=UA-129682534-1"></script><script>if (gaCode.startsWith('UA')) {window.initializeGoogleAnalytics = function() {(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,'script','//www.google-analytics.com/analytics.js','ga');ga('create', gaCode, {name: "customer",allowLinker: gaAllowLinker,});ga('customer.send', 'pageview');}} else {window.initializeGoogleAnalytics = function() {window.dataLayer = window.dataLayer || [];function gtag(){dataLayer.push(arguments);}gtag('js', new Date());gtag('config', gaCode);if (gaAllowLinker) {gtag('set', 'linker', 'lever.co');}}}</script><script type="text/javascript">/*We only want to not initialize Google Analytics and Segment on load if the following is true:- `gdpr` is enabled for the account- the account has the `cookieBanner` enabled- the account has the `optIn` cookieBanner typeThis is the only case where an applicant has to explicitly opt-in to the cookie consent before we can load GA/Segment*//* 2022-03-08: Disabling segment tracking due to an explosion in MAU after removing identify call */window.initializeGoogleAnalytics();window.hasInitializedAnalytics = true;</script></body></html><script src="/js/jquery-3.6.1.min.js"></script><script src="/js/list.js"></script>
-  recorded_at: Thu, 27 Jun 2024 13:37:12 GMT
+        <!DOCTYPE html><html><head prefix="og: http://ogp.me/ns#"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>GoTo Group</title><style>.template-btn-submit.hex-color {background: #00CC33;border-color: #00c230;color: white;}.template-btn-submit.hex-color:visited {color: white;}.template-btn-submit.hex-color:hover {background: #00c230;color: white;}.template-btn-submit.hex-color:active,.template-btn-submit.hex-color:focus {background: #008f24;color: white;}</style><meta name="twitter:card" value="summary"><meta name="twitter:title" content="GoTo Group"><meta name="twitter:description" content="Job openings at GoTo Group"><meta name="twitter:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733905611.png"><meta property="og:title" content="GoTo Group jobs" /><meta property="og:description" content="Job openings at GoTo Group" /><meta property="og:url" content="https://jobs.lever.co/GoToGroup" /><meta property="og:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733917014.png" /><meta property="og:image:height" content="630" /><meta property="og:image:width" content="1200" /><style>@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metaboldlf-webfont-2017.woff") format('woff');font-weight: 600;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormal-webfont-2017.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormalitaliclf-webfont-2017.woff") format('woff');font-weight: 400;font-style: italic;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metabolditaliclf-webfont-2017.woff") format('woff');font-weight: 600;font-style: italic;}@font-face {font-family: 'Meta-Caps';src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.eot");src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Avenir';src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.eot");src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.ttf") format('truetype');font-weight: normal;font-style: normal;}.caps-label,.classic-table th,h4,h6,th,.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.toggle-label,.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before,.cc-btn {font: 14px/1.4em 'Meta-Caps', sans-serif;text-transform: lowercase;letter-spacing: 1px;}.label,body,input,select,textarea,.btn-no-style,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {font: 400 14px/1.4em Meta, sans-serif;text-transform: none;letter-spacing: 0;}p.larger,.large-input,.large-input.dark,.message-banner {font: 400 16px/1.4em Meta, sans-serif;}h1,h2,h3,h5 {font: 600 16px/1.4em Meta, sans-serif;-webkit-font-smoothing: antialiased;}h1,h2,h3,h5 {color: #222326;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;top: 0;bottom: 0;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;right: 0;left: 0;}.hidden {display: none !important;}.fadein {-webkit-animation: lever-fadein 300ms ease-in;-moz-animation: lever-fadein 300ms ease-in;-o-animation: lever-fadein 300ms ease-in;-ms-animation: lever-fadein 300ms ease-in;animation: lever-fadein 300ms ease-in;opacity: 1;-ms-filter: none;filter: none;}.fadeout {-webkit-animation: lever-fadeout 300ms ease-in;-moz-animation: lever-fadeout 300ms ease-in;-o-animation: lever-fadeout 300ms ease-in;-ms-animation: lever-fadeout 300ms ease-in;animation: lever-fadeout 300ms ease-in;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.slidedown {-webkit-animation: lever-slidedown 300ms ease-in;-moz-animation: lever-slidedown 300ms ease-in;-o-animation: lever-slidedown 300ms ease-in;-ms-animation: lever-slidedown 300ms ease-in;animation: lever-slidedown 300ms ease-in;}.slideup {-webkit-animation: lever-slideup 300ms ease-out;-moz-animation: lever-slideup 300ms ease-out;-o-animation: lever-slideup 300ms ease-out;-ms-animation: lever-slideup 300ms ease-out;animation: lever-slideup 300ms ease-out;}.face-off {background-color: #f0f;}.face-off-border {border-color: #f0f !important;}.face-off-label {display: block;position: absolute;top: 24px;font-size: 24px;width: 100%;text-align: center;color: #fff;}.comma-separated:after {content: ", ";}.comma-separated:last-of-type:after {content: "";}.numbers,.dates,.count {font-family: 'Avenir';font-size: 0.857em;}.numbers,.dates {font-size: 0.92em;text-transform: uppercase;}.label {font-size: 12px;color: #969799;}.label.dark {color: #6a7c83;}.caps-label,.classic-table th {font-size: 12px;color: #969799;}.caps-label.dark,.classic-table th.dark {color: #6a7c83;}.vert-space-1 {margin-top: 5px;}.vert-space-2 {margin-top: 10px;}.vert-space-3 {margin-top: 15px;}.vert-space-4 {margin-top: 20px;}.vert-space-5 {margin-top: 25px;}.vert-space-6 {margin-top: 30px;}.vert-space-7 {margin-top: 35px;}.vert-space-8 {margin-top: 40px;}.vert-space-9 {margin-top: 45px;}.vert-space-10 {margin-top: 50px;}.vert-space-11 {margin-top: 55px;}.vert-space-12 {margin-top: 60px;}.full-width {width: 100%;}.left-align {text-align: left;}.right-align {text-align: right;}.centered {text-align: center;}.bulleted-list,.numbered-list {margin-left: 15px;}.bulleted-list li,.numbered-list li {margin-bottom: 8px;}.classic-table.fixed {table-layout: fixed;}.classic-table.no-padding td,.classic-table.no-padding th {padding: initial;}.classic-table.dark td,.classic-table.dark th {border-bottom: 1px solid #536266;}.classic-table.dark th {color: #6a7c83;}.classic-table td,.classic-table th {border-bottom: 1px solid #e3e4e6;padding: 10px 15px;vertical-align: top;}.classic-table td:first-of-type,.classic-table th:first-of-type {padding-left: 0;}.classic-table.no-bottom-border tr:last-child > td,.classic-table.no-bottom-border tr:last-child > th {border-bottom: none;}@-moz-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}* {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}body {background: #f9f9f9;color: #555659;}th {text-align: left;}body,dd,dl,dt,fieldset,form,h1,h2,h3,h4,h5,h6,li,menu,ol,p,td,th,ul,.toggle-label,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;}ul {margin: 0 auto;}table {border-collapse: collapse;border-spacing: 0;}fieldset,img {border: 0;}img.desaturate {-webkit-filter: grayscale(100%);}h1 {font-size: 36px;}h2,h5 {font-size: 24px;}h3 {font-size: 18px;}h5 {font-size: 16px;}h6,th {font-size: 12px;}a,a:visited {color: #579eee;text-decoration: none;}a:hover {color: #555659;cursor: pointer;}a:active {color: #0c92f3;}p>a {text-decoration: underline;color: inherit;}b {font-weight: 600;-webkit-font-smoothing: antialiased;}input,select,textarea {color: #555659;margin: 0;}input,select {height: 30px;}section {padding-bottom: 16px;}button {-webkit-appearance: button;-moz-appearance: button;appearance: button;cursor: pointer;}.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.cc-btn {position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 5px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;color: #555659;background: #fcfcfc;background: -webkit-linear-gradient(top, #fff, #f9f9f9);background: -moz-linear-gradient(top, #fff, #f9f9f9);background: -o-linear-gradient(top, #fff, #f9f9f9);background: -ms-linear-gradient(top, #fff, #f9f9f9);background: linear-gradient(to bottom, #fff, #f9f9f9);-webkit-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-moz-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-o-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-ms-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;}.btn:hover,.submit:hover,.btn-large:hover,.submit-large:hover,.btn-large-secondary:hover,.dark-button:hover,.cc-btn:hover,.btn-invisible:hover,.btn-no-style:hover {color: #1a1b1c;border-color: #969799;}.btn:active,.submit:active,.btn-large:active,.submit-large:active,.btn-large-secondary:active,.dark-button:active,.cc-btn:active {border-color: #555659;background: -webkit-linear-gradient(top, #f9f9f9, #fff);background: -moz-linear-gradient(top, #f9f9f9, #fff);background: -o-linear-gradient(top, #f9f9f9, #fff);background: -ms-linear-gradient(top, #f9f9f9, #fff);background: linear-gradient(to bottom, #f9f9f9, #fff);}.btn:active .icon >path,.submit:active .icon >path,.btn-large:active .icon >path,.submit-large:active .icon >path,.btn-large-secondary:active .icon >path,.dark-button:active .icon >path,.cc-btn:active .icon >path {fill: #555659;}.btn:focus,.submit:focus,.btn-large:focus,.submit-large:focus,.btn-large-secondary:focus,.dark-button:focus,.cc-btn:focus {outline: thin dotted;outline: 3px auto #0c92f3;outline-offset: -2px;}.btn.disabled,.submit.disabled,.btn-large.disabled,.submit-large.disabled,.btn-large-secondary.disabled,.dark-button.disabled,.cc-btn.disabled,.btn:disabled,.submit:disabled,.btn-large:disabled,.submit-large:disabled,.btn-large-secondary:disabled,.dark-button:disabled,.cc-btn:disabled,input.btn:disabled {cursor: default;pointer-events: none;-webkit-box-shadow: none;box-shadow: none;background: #e3e4e6;color: #555659;border-color: #dcdcdc;outline: none;}.btn.disabled.has-tip,.submit.disabled.has-tip,.btn-large.disabled.has-tip,.submit-large.disabled.has-tip,.btn-large-secondary.disabled.has-tip,.dark-button.disabled.has-tip,.cc-btn.disabled.has-tip,.btn:disabled.has-tip,.submit:disabled.has-tip,.btn-large:disabled.has-tip,.submit-large:disabled.has-tip,.btn-large-secondary:disabled.has-tip,.dark-button:disabled.has-tip,.cc-btn:disabled.has-tip,input.btn:disabled.has-tip {pointer-events: auto;}.btn.disabled:hover,.submit.disabled:hover,.btn-large.disabled:hover,.submit-large.disabled:hover,.btn-large-secondary.disabled:hover,.dark-button.disabled:hover,.cc-btn.disabled:hover,.btn:disabled:hover,.submit:disabled:hover,.btn-large:disabled:hover,.submit-large:disabled:hover,.btn-large-secondary:disabled:hover,.dark-button:disabled:hover,.cc-btn:disabled:hover,input.btn:disabled:hover,.btn.disabled:active,.submit.disabled:active,.btn-large.disabled:active,.submit-large.disabled:active,.btn-large-secondary.disabled:active,.dark-button.disabled:active,.cc-btn.disabled:active,.btn:disabled:active,.submit:disabled:active,.btn-large:disabled:active,.submit-large:disabled:active,.btn-large-secondary:disabled:active,.dark-button:disabled:active,.cc-btn:disabled:active,input.btn:disabled:active {color: #555659;background: #e3e4e6;border-color: #dcdcdc;}.btn.dropdown-button,.submit.dropdown-button,.btn-large.dropdown-button,.submit-large.dropdown-button,.btn-large-secondary.dropdown-button,.dark-button.dropdown-button,.cc-btn.dropdown-button {text-align: left;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;padding-right: 19px;}.btn.dropdown-button.full-width,.submit.dropdown-button.full-width,.btn-large.dropdown-button.full-width,.submit-large.dropdown-button.full-width,.btn-large-secondary.dropdown-button.full-width,.dark-button.dropdown-button.full-width,.cc-btn.dropdown-button.full-width {width: 100%;}.btn .icon >path,.submit .icon >path,.btn-large .icon >path,.submit-large .icon >path,.btn-large-secondary .icon >path,.dark-button .icon >path,.cc-btn .icon >path {fill: #555659;}.btn.has-icon,.submit.has-icon,.btn-large.has-icon,.submit-large.has-icon,.btn-large-secondary.has-icon,.dark-button.has-icon,.cc-btn.has-icon {padding-left: 41px;}.btn.has-icon .icon,.submit.has-icon .icon,.btn-large.has-icon .icon,.submit-large.has-icon .icon,.btn-large-secondary.has-icon .icon,.dark-button.has-icon .icon,.cc-btn.has-icon .icon,.btn.has-icon .loading-indicator,.submit.has-icon .loading-indicator,.btn-large.has-icon .loading-indicator,.submit-large.has-icon .loading-indicator,.btn-large-secondary.has-icon .loading-indicator,.dark-button.has-icon .loading-indicator,.cc-btn.has-icon .loading-indicator {position: absolute;left: 15px;top: calc(50% - 8px);}.btn.has-icon .btn-content,.submit.has-icon .btn-content,.btn-large.has-icon .btn-content,.submit-large.has-icon .btn-content,.btn-large-secondary.has-icon .btn-content,.dark-button.has-icon .btn-content,.cc-btn.has-icon .btn-content {position: relative;display: inline-block;}.btn.has-icon .btn-content .icon,.submit.has-icon .btn-content .icon,.btn-large.has-icon .btn-content .icon,.submit-large.has-icon .btn-content .icon,.btn-large-secondary.has-icon .btn-content .icon,.dark-button.has-icon .btn-content .icon,.cc-btn.has-icon .btn-content .icon,.btn.has-icon .btn-content .loading-indicator,.submit.has-icon .btn-content .loading-indicator,.btn-large.has-icon .btn-content .loading-indicator,.submit-large.has-icon .btn-content .loading-indicator,.btn-large-secondary.has-icon .btn-content .loading-indicator,.dark-button.has-icon .btn-content .loading-indicator,.cc-btn.has-icon .btn-content .loading-indicator {left: -26px;}.btn.has-icon.right,.submit.has-icon.right,.btn-large.has-icon.right,.submit-large.has-icon.right,.btn-large-secondary.has-icon.right,.dark-button.has-icon.right,.cc-btn.has-icon.right {padding-left: 15px;padding-right: 41px;}.btn.has-icon.right .icon,.submit.has-icon.right .icon,.btn-large.has-icon.right .icon,.submit-large.has-icon.right .icon,.btn-large-secondary.has-icon.right .icon,.dark-button.has-icon.right .icon,.cc-btn.has-icon.right .icon {right: 15px;left: initial;}.btn small,.submit small,.btn-large small,.submit-large small,.btn-large-secondary small,.dark-button small,.cc-btn small {margin-left: 10px;font-size: 12px;opacity: 0.67;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=67)";filter: alpha(opacity=67);}.btn small.dates,.submit small.dates,.btn-large small.dates,.submit-large small.dates,.btn-large-secondary small.dates,.dark-button small.dates,.cc-btn small.dates {font-size: 11px;}.submit,.submit-large {color: #fff;background: #0c92f3;border: 1px solid #0c92f3;}.submit .icon >path,.submit-large .icon >path {fill: #fff;}.submit:hover,.submit-large:hover {color: #fff;background: #007fd9;border: 1px solid #0c92f3;}.submit:active,.submit-large:active {background: #1a1b1c;border-color: #1a1b1c;}.submit:active .icon >path,.submit-large:active .icon >path {fill: #fff;}.submit:focus,.submit-large:focus {outline-color: #064979;}.btn-large,.btn-large-secondary {padding: 10px 15px;}.submit-large {padding: 10px 15px;}.btn-large-secondary {background: #969799;color: #fff;border: 1px solid #969799;}.btn-large-secondary:hover {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary:active {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary .icon >path {fill: #e3e4e6;}a.btn,a.btn-large {color: #555659;}a.submit,a.submit-large,a.btn-large-secondary {color: #fff;}.dark-button {background: #2c2e2f;border: 1px solid rgba(106,124,131,0.75);color: #e3e4e6;-webkit-transition: background-color 0.15s;-moz-transition: background-color 0.15s;-o-transition: background-color 0.15s;-ms-transition: background-color 0.15s;transition: background-color 0.15s;}.dark-button .icon >path {fill: #dcdcdc;}.dark-button.disabled,.dark-button:disabled {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;pointer-events: none;}.dark-button.disabled .icon > path,.dark-button:disabled .icon > path {fill: rgba(106,124,131,0.5);}.dark-button.disabled.has-tip,.dark-button:disabled.has-tip {pointer-events: auto;}.dark-button.disabled.has-tip:hover,.dark-button:disabled.has-tip:hover {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;}.dark-button.transparent {background-color: transparent;}.dark-button:hover {background: #1a1b1c;border-color: #7d8f95;color: #fcfcfc;}.dark-button:hover .icon > path {fill: #fff;}.dark-button:active {border-color: #dcdcdc;}.icon-only {position: relative;width: 32px;height: 30px;}.icon-only .icon {position: absolute;left: calc(50% - 8px);top: calc(50% - 8px);}.icon-only:hover .icon >path {fill: #555659;}.icon-only:active .icon >path {fill: #2c2e2f;}.icon-only.dark-button:hover .icon >path {fill: #fff;}.btn-invisible,.btn-no-style {color: #555659;padding: 5px 15px;border-color: transparent;-webkit-box-shadow: inset 0 0 0 1px transparent;box-shadow: inset 0 0 0 1px transparent;background: transparent;-webkit-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-moz-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-o-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-ms-transition: background 0.15s, box-shadow 0.15s, color 0.15s;transition: background 0.15s, box-shadow 0.15s, color 0.15s;}.btn-invisible.disabled,.btn-no-style.disabled,.btn-invisible:disabled,.btn-no-style:disabled {cursor: default;}.btn-no-style {padding: 5px 10px 5px 0;vertical-align: baseline;}.btn-no-style:hover {border-color: transparent;color: #555659;}.btn-no-style:focus {border-radius: 0;outline: none;}.btn-no-style.dark {color: #7d8f95;}.btn-no-style.dark:hover {color: #f9f9f9;}.btn-no-style.dark:active {background: transparent;border-color: transparent;color: #fff;}.btn-no-style .css-icon::before {right: 0;}.link {display: inline-block;position: relative;cursor: pointer;-webkit-transition: all 0.15s;-moz-transition: all 0.15s;-o-transition: all 0.15s;-ms-transition: all 0.15s;transition: all 0.15s;}.link.has-icon {padding-left: 20px;}.link.has-icon .icon {position: absolute;left: 0;top: calc(50% - 8px);}.link.has-icon .icon >path {fill: #969799;}.link.has-icon .icon-plus,.link.has-icon .icon-close,.link.has-icon .icon-delete {top: calc(50% - 10px);}.link.has-icon:hover .icon >path {fill: #555659;}.link.has-icon:active .icon >path {fill: #0c92f3;}.link.dark,.popup-content .link {color: #7d8f95;}.link.dark .icon >path,.popup-content .link .icon >path {fill: #7d8f95;}.link.dark:hover,.popup-content .link:hover {color: #dcdcdc;}.link.dark:hover .icon >path,.popup-content .link:hover .icon >path {fill: #dcdcdc;}.link.dark:active,.popup-content .link:active {color: #fff;}.link.secondary {color: #969799;}.link.secondary:hover {color: #555659;}button.icon-btn {border: 0;background: none;padding: 0;}button.icon-btn:active {outline: none;}.icon-btn {display: inline-block;margin-left: 10px;vertical-align: middle;}.icon-btn .icon {display: block;}.icon-btn .icon >path {fill: #969799;}.icon-btn:hover .icon >path {fill: #555659;}.icon-btn.dark .icon >path {fill: #6a7c83;}.icon-btn.dark:hover .icon >path {fill: #f9f9f9;}.link-bar {display: block;margin-top: 16px;white-space: nowrap;}.link-bar.no-margin {margin-top: 0;}.link-bar .submit,.link-bar .submit-large,.link-bar .dark-button {min-width: 120px;}.link-bar a,.link-bar button {vertical-align: baseline;}.link-bar.right,.link-bar.center {text-align: right;}.link-bar.right a,.link-bar.center a,.link-bar.right button,.link-bar.center button {margin-right: 15px;}.link-bar.right .btn,.link-bar.center .btn,.link-bar.right .dark-button,.link-bar.center .dark-button,.link-bar.right .submit,.link-bar.center .submit {margin-right: 10px;}.link-bar.right *:nth-last-child(1),.link-bar.center *:nth-last-child(1) {margin-right: 0;}.link-bar.left {text-align: left;}.link-bar.left a,.link-bar.left button {margin-left: 15px;}.link-bar.left .btn,.link-bar.left .dark-button,.link-bar.left .submit {margin-left: 10px;}.link-bar.left *:first-child {margin-left: 0;}.link-bar.center {text-align: center;}input[type=radio],input[type=checkbox] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 17px;height: 17px;position: relative;border: 1px solid #dcdcdc;margin: 0;background: #fff;cursor: pointer;}input[type=radio].disabled,input[type=checkbox].disabled,input[type=radio]:disabled,input[type=checkbox]:disabled {background: #e3e4e6;}input[type=radio].dark,input[type=checkbox].dark {background: rgba(106,124,131,0.2);border-color: rgba(106,124,131,0.8);}input[type=radio].dark:checked,input[type=checkbox].dark:checked {background: #dcdcdc;}input[type=radio].dark:focus,input[type=checkbox].dark:focus {background: #f9f9f9;}input[type=radio].dark:active,input[type=checkbox].dark:active {background: #fff;}input[type=radio].dark.disabled,input[type=checkbox].dark.disabled,input[type=radio].dark:disabled,input[type=checkbox].dark:disabled {background: rgba(106,124,131,0.5);}input[type=radio] {border-radius: 8.5px;}input[type=radio]:active {background: #dcdcdc;}input[type=radio]:checked::after {position: absolute;content: "";height: 9px;width: 9px;left: calc(50% - 4.5px);top: calc(50% - 4.5px);border-radius: 4.25px;background-color: #0c92f3;}input[type=checkbox] {border-radius: 3px;}input[type=checkbox]:active {background: #dcdcdc;}input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: 3%;height: 40%;width: 69%;border-bottom: 2px solid #0c92f3;border-left: 2px solid #0c92f3;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}input[type=submit] {height: inherit;}input.required-checkbox[type=checkbox]:hover::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);left: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAADe0lEQVRYCe2WW0jTYRTA3V3pZRWEJJJFUQQFRtCFogt7kV7cxVkGmlBPdoHepCh6CCHoJYIIyvlgLYdzUfjQnSjoQXpIYUSZ9aZQQmNzDHVbvzPa+O/bf9sf0Tf/8PF9536+c853zt9Us4RvZGTkuMlkeqOITrrd7m0KriporsqxwgyrDqxGYDUCVnlloVBoK1vC7/fPrPCrK6gPh8P70+n0WM4Bq9XaB8VDg3nPHlpcXAzjzO8C9zIdhoeH95rN5nbUtdHINmUyGZeV29cBtICUejgmC4fuRiKRdzAMQYt4PJ5Z8Ev6MNqMUT/CfnRt0SqxWCw+bFnF+BotAUYLsAtBF/s9IvOaPRSLxSLd3d1/tbx6Zy61C71yUzFatj1Dc5tQ/pjDKT1FKi6bzc6De8WaROaSlg5thnUffDtrh5ZW6WyFuQ7BNLvcuuIHjx2GE3pM0OpZ1/Vo5XDYnTUzwdypVKoB4DyMH1jZcgLLhJcUDmCvZXx8vN6kKiV/DRRHG/k/CW2fSl8KjLEE0XnGs3tCYb/ghUkqc1+JA3mC7MFgsMlut0shSV73aGkGzkkMj8pLisfjoxRvSk+mogNaAWlWRKaLyFzV4tUzRqfAXUkkEs87OzvnVLoKG54FhE0qf62qQAduhG/KiHGRNewADaUVxT06BotQ8NhADAUCAWcRoQxgyAFqoZHQP9TT8T/kKqnJ6XQGVKQeXNUBcm+pra19xM3WqQowPsg6xNKbG62086JmpcoLXNUBWuo1+A7rCP9KJpM9Xq93mko/A72kf+DYLRlAOrIFVMVXQJs+Audbbl/kKIrT4I8ypD7mNcF7G77LeViz/1xYWGimiGMaXOFYpLiA5YDC9WwS+hIeHOjTGhc5Rngv22c5K99motiv4ApgifICpaamH+MNGjh3xPjYxMTEDRUv3Y2bSveMqzT0ePgBuaDiBdZNgTBT9Xd0BOZop80+n++7Di2HInKnMTio0nF8HvxBRk9RlEocoOq322y2LyhwqEootnMU3QMVr8I4MYCxLhWPEz9I1U7tLChJQTQaldv1wZxRFDw1YlxkaMM9yH9T5CU1vVrjQi+JQF6INLi4hRThBpRNM7J3d3R0/MnTq+3yK8bs+ASfRDJK6ryk7qsqV9YBYaQDbnQ4HEGcuEnuXqrC1WBScRGeA0TkrNHZUE3nstP/Ae08V3wBOebTAAAAAElFTkSuQmCC");background-position: 50% 50%;}input.required-checkbox[type=checkbox]:checked {border: none;background: #f26161;}input.required-checkbox[type=checkbox]:checked:hover {background: #d95757;}input.required-checkbox[type=checkbox]:checked:disabled {background: #f8b0b0;cursor: auto;}input[type=checkbox].required-checkbox:checked::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABtklEQVRIDe2UzStEYRSHZwxpwpSNlNQUEQsbSztK7BUmbKzITvkPWMjKjpSywlIpSc1CkWxkQ5IslCQpHwvCeM6k27nnvnfuhKyceu49H79z3vv5xmJFWi6X2wBtjcW0lhQj+onmf4HIp/c3j4hPYxjqIi+nSAGzyqAXWmIc0iD2AbswAbV2FrmCnyn1UuiGJbgDsXlZYDLv+g/vhFkYgxpZjHNgAXIJ6IQFuAVrV9K4b7MmfiPegTOTXye+MblAGCfTzwUOQg+Uw2/ZCYPWvGEslIIR2IRX+I6d0zQNbd5gl4OgGkZhG+QRFbJLirPQ7poVmaNRvoww26IQjxwSJqC5Ak7Dpn/lh8L6I/MMWDbDX4gPTO6RuDlymBXQlDGDJJyCGriWQNkxftLOCI0RN8CDGiBuFvJ7F+cukJ9R22LoQF2gQ/aRQ92Jfw/1RjdjNBJmtMbpI5pzNMrP6DM0svfsGa28jyafUAcU5dZl09O2ojXaR5QGuTttRwQJrfN8CpWwqtQX+ClP4HCo9yn9E/6AQ+ZPIRqHZ+jwV9wROtlN5X9pdSscWcT5bdpRCqTQJqEqUCDxCYHVRpVrffeeAAAAAElFTkSuQmCC");background-position: 50% 50%;}input::placeholder,textarea::placeholder {color: #969799;}input:-ms-input-placeholder,textarea:-ms-input-placeholder {color: #969799;}.classic-input,.large-input {-webkit-transition: border-color 0.15s, background 0.15s;-moz-transition: border-color 0.15s, background 0.15s;-o-transition: border-color 0.15s, background 0.15s;-ms-transition: border-color 0.15s, background 0.15s;transition: border-color 0.15s, background 0.15s;border: 1px solid #e3e4e6;background-color: #fff;padding: 4px 10px;border-radius: 3px;}.classic-input.invalid,.large-input.invalid {border: 1px solid #d94141;}.classic-input.invalid:focus,.large-input.invalid:focus {outline: none;}.classic-input.invalid:hover,.large-input.invalid:hover {border: 1px solid #d94141;}.classic-input:hover,.large-input:hover {background-color: #fff;border-color: rgba(12,146,243,0.5);}.classic-input:active,.large-input:active,.classic-input:focus,.large-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #fff;border-color: #0c92f3;}.classic-input.disabled,.large-input.disabled,.classic-input:disabled,.large-input:disabled {background: #f9f9f9;color: #969799;}.classic-input.disabled:hover,.large-input.disabled:hover,.classic-input:disabled:hover,.large-input:disabled:hover,.classic-input.disabled:active,.large-input.disabled:active,.classic-input:disabled:active,.large-input:disabled:active {border-color: #e3e4e6;}.classic-input::-ms-clear,.large-input::-ms-clear {display: none;}textarea.classic-input {resize: vertical;}.hoverable-input {-webkit-transition: border-color 0.3s, background-color 0.3s;-moz-transition: border-color 0.3s, background-color 0.3s;-o-transition: border-color 0.3s, background-color 0.3s;-ms-transition: border-color 0.3s, background-color 0.3s;transition: border-color 0.3s, background-color 0.3s;border: 1px solid transparent;background-color: transparent;padding: 4px 10px;border-radius: 3px;}.hoverable-input.invalid {border: 1px solid #d94141;outline: none;}.hoverable-input:hover {background-color: #fff;border-color: #e3e4e6;}.hoverable-input:active,.hoverable-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #f9f9f9;border-color: #e3e4e6;}.dark-input,.large-input.dark {height: 30px;color: #f9f9f9;padding: 4px 10px;background: rgba(106,124,131,0.5);border: none;color: #e3e4e6;border-radius: 3px;}.dark-input.invalid,.large-input.dark.invalid {border: 1px solid #d94141;}.dark-input.invalid:focus,.large-input.dark.invalid:focus {outline: none;}.dark-input.invalid:hover,.large-input.dark.invalid:hover {border: 1px solid #d94141;}.dark-input:hover,.large-input.dark:hover {background: #6a7c83;}.dark-input:focus,.large-input.dark:focus {background: #fff;color: #555659;outline: none;}textarea.dark-input {height: auto;}.large-input {height: 40px;}.large-input.dark {height: 40px;}.no-input {background: none;border: none;outline: none;-webkit-box-shadow: none;box-shadow: none;margin: 0;padding: 0;resize: none;}.no-input.dark {color: #f9f9f9;}.options-list {list-style-type: none;}.options-list li {margin-bottom: 8px;}.options-list li.list-padding {margin-bottom: 16px;}.options-list label {display: block;position: relative;cursor: pointer;}.options-list label input[type=checkbox],.options-list label input[type=radio] {position: absolute;}.options-list label input[type=checkbox] ~ span,.options-list label input[type=radio] ~ span,.options-list label input[type=checkbox] ~ p,.options-list label input[type=radio] ~ p {padding-left: 26px;display: block;color: #555659;}.options-list label input[type=checkbox]:checked ~ span,.options-list label input[type=radio]:checked ~ span,.options-list label input[type=checkbox]:checked ~ p,.options-list label input[type=radio]:checked ~ p {color: #555659;}.popup-content .options-list input[type="checkbox"],.sheets-content .options-list input[type="checkbox"],.modal-legacy.dark .options-list input[type="checkbox"],.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {background: rgba(106,124,131,0.5);border-color: rgba(106,124,131,0.8);}.popup-content .options-list input[type="checkbox"] ~ span,.sheets-content .options-list input[type="checkbox"] ~ span,.modal-legacy.dark .options-list input[type="checkbox"] ~ span,.popup-content .options-list input[type="radio"] ~ span,.sheets-content .options-list input[type="radio"] ~ span,.modal-legacy.dark .options-list input[type="radio"] ~ span,.popup-content .options-list input[type="checkbox"] ~ p,.sheets-content .options-list input[type="checkbox"] ~ p,.modal-legacy.dark .options-list input[type="checkbox"] ~ p,.popup-content .options-list input[type="radio"] ~ p,.sheets-content .options-list input[type="radio"] ~ p,.modal-legacy.dark .options-list input[type="radio"] ~ p {color: #a4b0b4;}.popup-content .options-list input[type="checkbox"]:checked,.sheets-content .options-list input[type="checkbox"]:checked,.modal-legacy.dark .options-list input[type="checkbox"]:checked,.popup-content .options-list input[type="radio"]:checked,.sheets-content .options-list input[type="radio"]:checked,.modal-legacy.dark .options-list input[type="radio"]:checked {background: #dcdcdc;}.popup-content .options-list input[type="checkbox"]:checked ~ span,.sheets-content .options-list input[type="checkbox"]:checked ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ span,.popup-content .options-list input[type="radio"]:checked ~ span,.sheets-content .options-list input[type="radio"]:checked ~ span,.modal-legacy.dark .options-list input[type="radio"]:checked ~ span,.popup-content .options-list input[type="checkbox"]:checked ~ p,.sheets-content .options-list input[type="checkbox"]:checked ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ p,.popup-content .options-list input[type="radio"]:checked ~ p,.sheets-content .options-list input[type="radio"]:checked ~ p,.modal-legacy.dark .options-list input[type="radio"]:checked ~ p {color: #f9f9f9;}.popup-content .options-list input[type="checkbox"]:focus,.sheets-content .options-list input[type="checkbox"]:focus,.modal-legacy.dark .options-list input[type="checkbox"]:focus,.popup-content .options-list input[type="radio"]:focus,.sheets-content .options-list input[type="radio"]:focus,.modal-legacy.dark .options-list input[type="radio"]:focus {background: #f9f9f9;}.popup-content .options-list input[type="checkbox"].disabled,.sheets-content .options-list input[type="checkbox"].disabled,.modal-legacy.dark .options-list input[type="checkbox"].disabled,.popup-content .options-list input[type="radio"].disabled,.sheets-content .options-list input[type="radio"].disabled,.modal-legacy.dark .options-list input[type="radio"].disabled,.popup-content .options-list input[type="checkbox"]:disabled,.sheets-content .options-list input[type="checkbox"]:disabled,.modal-legacy.dark .options-list input[type="checkbox"]:disabled,.popup-content .options-list input[type="radio"]:disabled,.sheets-content .options-list input[type="radio"]:disabled,.modal-legacy.dark .options-list input[type="radio"]:disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="checkbox"].disabled ~ span,.sheets-content .options-list input[type="checkbox"].disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ span,.popup-content .options-list input[type="radio"].disabled ~ span,.sheets-content .options-list input[type="radio"].disabled ~ span,.modal-legacy.dark .options-list input[type="radio"].disabled ~ span,.popup-content .options-list input[type="checkbox"]:disabled ~ span,.sheets-content .options-list input[type="checkbox"]:disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ span,.popup-content .options-list input[type="radio"]:disabled ~ span,.sheets-content .options-list input[type="radio"]:disabled ~ span,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ span,.popup-content .options-list input[type="checkbox"].disabled ~ p,.sheets-content .options-list input[type="checkbox"].disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ p,.popup-content .options-list input[type="radio"].disabled ~ p,.sheets-content .options-list input[type="radio"].disabled ~ p,.modal-legacy.dark .options-list input[type="radio"].disabled ~ p,.popup-content .options-list input[type="checkbox"]:disabled ~ p,.sheets-content .options-list input[type="checkbox"]:disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ p,.popup-content .options-list input[type="radio"]:disabled ~ p,.sheets-content .options-list input[type="radio"]:disabled ~ p,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ p {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {border-radius: 8.5px;}.loading-indicator {display: inline-block;border-radius: 30px;-webkit-animation: loading 1.2s infinite linear;-moz-animation: loading 1.2s infinite linear;-o-animation: loading 1.2s infinite linear;-ms-animation: loading 1.2s infinite linear;animation: loading 1.2s infinite linear;width: 30px;height: 30px;border: 4px solid #0c92f3;border-top: 4px solid #e3e4e6;border-left: 4px solid #e3e4e6;vertical-align: middle;}.loading-indicator.small {margin-right: 10px;width: 16px;height: 16px;border: 2px solid #0c92f3;border-top: 2px solid #e3e4e6;border-left: 2px solid #e3e4e6;}.loading-indicator.small.completed {border: 2px solid #555659;}.loading-indicator.small.completed .icon {vertical-align: top;width: 10px;height: 10px;}.loading-indicator.completed {border: 4px solid #555659;text-align: center;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;}.loading-indicator .icon {margin-left: 1px;height: 100%;vertical-align: middle;}.loading-indicator .icon >path {fill: #39bf87;}.loading-indicator.fadein {-webkit-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-moz-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-o-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-ms-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}.css-icon {display: inline-block;width: 16px;height: 1px;}.css-icon::before {position: absolute;display: block;content: "";right: 10px;top: calc(50% - 8px);width: 16px;height: 16px;}.css-icon-plus::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path d='M7.5,3h1v4.5H13v1H8.5V13h-1V8.5H3v-1h4.5V3z'></path></svg>") no-repeat 0 0;}.css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23979797' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.btn-no-style.dark:hover .css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23DCDCDC' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.toggle-label {clear: left;color: #969799;line-height: 22px;}.toggle-label button {float: left;margin-right: 10px;}.toggle-slider {margin-left: 10px;background: #fff;width: 45px;height: 22px;border-radius: 11px;position: relative;vertical-align: middle;border: 1px solid #dcdcdc;-webkit-transition: background 150ms;-moz-transition: background 150ms;-o-transition: background 150ms;-ms-transition: background 150ms;transition: background 150ms;}.toggle-slider:focus {outline: none;}.toggle-slider:hover {background-color: #f9f9f9;}.toggle-slider .ball {height: 16px;width: 16px;border-radius: 8px;position: absolute;background-color: #dcdcdc;left: 2px;top: 2px;right: auto;-webkit-transition: 150ms;-moz-transition: 150ms;-o-transition: 150ms;-ms-transition: 150ms;transition: 150ms;}.toggle-slider .ball:hover {background: #969799;}.toggle-slider.on .ball {left: 25px;background: #39bf87;}.toggle-slider.on .ball:hover {background: #30a272;}.message-banner {position: relative;display: inline-block;margin-bottom: 20px;padding: 9px 15px;border-radius: 3px;background: #e1f3ff;color: #6a7c83;}.message-banner.full-width {display: block;}.message-banner.centered {text-align: center;}.message-banner.has-icon {padding-left: 41px;}.message-banner.has-dismiss {padding-right: 41px;}.message-banner.has-dismiss .icon-btn {position: absolute;right: 15px;top: 6px;}.message-banner.has-dismiss .icon-btn .icon {position: relative;left: inherit;top: inherit;}.message-banner.has-button {padding-top: 14px;padding-right: 180px;padding-bottom: 14px;}.message-banner.has-button .icon {top: 15px;}.message-banner.has-button .btn,.message-banner.has-button button {position: absolute;right: 10px;top: 10px;}.message-banner a,.message-banner a:visited {color: #555659;}.message-banner a:hover,.message-banner a:visited:hover {color: #1a1b1c;}.message-banner .icon {position: absolute;left: 15px;top: 10px;}.message-banner .icon >path {fill: #6a7c83;}.message-banner .label {color: #555659;}.message-banner .btn {float: right;}.message-banner.warning {background: #fec;}.message-banner.error {background: #ffe6e6;color: #555659;}.message-banner.error .label {color: #555659;}.message-banner.error .icon >path {fill: #555659;}.what-is-this {display: inline-block;color: #969799;cursor: default;padding-left: 4px;font-size: 12px;}.what-is-this.dark {color: #6a7c83;}.what-is-this.dark:hover {color: #f9f9f9;}.what-is-this .icon >path {fill: #969799;}.what-is-this:hover {color: #555659;}.what-is-this:hover .icon >path {fill: #555659;}.what-is-this-icon {display: inline-block;margin-left: 10px;}.what-is-this-icon .icon {width: 12px;height: 12px;}.what-is-this-icon .icon >path {fill: #969799;}.what-is-this-icon:hover .icon >path {fill: #555659;}.what-is-this-icon.no-margin {margin-left: 4px;}.what-is-this-icon.dark .icon >path {fill: #6a7c83;}.what-is-this-icon.dark:hover .icon >path {fill: #dde5e7;}.gated-feature,.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter,.gated-feature-block,.gated-feature-block-pro {position: relative;cursor: pointer;background: rgba(227,228,230,0.5);}.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before {content: 'Enterprise';font-size: 12px;color: #fff;background-color: #39bf87;border-radius: 3px;padding: 2px 10px;position: absolute;right: 15px;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {cursor: pointer;content: '';border-radius: 3px;border: 1px solid #e3e4e6;}.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter {border: 1px solid #e3e4e6;border-radius: 3px;}.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before {content: 'Enterprise';position: absolute;float: right;top: 50%;-webkit-transform: translateY(-50%);-moz-transform: translateY(-50%);-o-transform: translateY(-50%);-ms-transform: translateY(-50%);transform: translateY(-50%);margin-left: 10px;}.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after {content: none;display: none;}.gated-feature-inline *,.gated-feature-inline-enterprise *,.gated-feature-inline-professional *,.gated-feature-inline-starter * {pointer-events: none;}.gated-feature-inline-professional:before {content: 'Pro';}.gated-feature-inline-starter:before {content: 'Starter';}.gated-feature-block,.gated-feature-block-pro {margin-top: 32px;padding: 15px 15px;}.gated-feature-block:before,.gated-feature-block-pro:before {top: 15px;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;}.gated-feature-block:after,.gated-feature-block-pro:after {pointer-events: none;}.gated-feature-block-pro:before {content: 'Pro';}.gated-ad {max-width: 600px;min-height: 270px;}.gated-ad .pull-left {float: left;margin-right: 70px;}.gated-ad div.pull-left,.gated-ad div.image {margin-top: 25px;}.gated-ad ul li {margin: 0 0 32px 0;list-style: none;}.gated-ad ul li .icon {vertical-align: sub;margin-right: 10px;}.gated-ad ul li .icon > path {fill: #969799;}.momentum-body,.badge,.theme-inverse .button.button-link,.button.button-link,.font-base {font-family: 'Meta', sans-serif;letter-spacing: 0;text-transform: none;}.momentum-body .icon,.badge .icon,.theme-inverse .button.button-link .icon,.button.button-link .icon,.font-base .icon,.momentum-body .momentum-body .icon,.momentum-body .badge .icon,.momentum-body .theme-inverse .button.button-link .icon,.momentum-body .button.button-link .icon,.momentum-body .font-base .icon {vertical-align: -0.15em;}.momentum-body {color: #222326;font-size: 16px;font-weight: normal;line-height: 24px;margin: 0;}.button,.mo-identicon-initials,.col-list-row-header,.nav-link,.font-caps {font-family: 'Meta-Caps', 'Meta', sans-serif;letter-spacing: 1px;text-transform: lowercase;}.button .icon,.mo-identicon-initials .icon,.col-list-row-header .icon,.nav-link .icon,.font-caps .icon,.momentum-body .button .icon,.momentum-body .mo-identicon-initials .icon,.momentum-body .col-list-row-header .icon,.momentum-body .nav-link .icon,.momentum-body .font-caps .icon {vertical-align: -0.188em;}.form-control,.font-inherit {font-family: inherit;letter-spacing: inherit;text-transform: inherit;}.theme-inverse .button {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.theme-inverse,.theme-inverse .text-base,.theme-inverse .text-small,.theme-inverse .text-caption {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5,.momentum-body b,.momentum-body strong,.text-h1,.text-h2,.text-h3,.text-h3_5,.text-h4,.text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5,.theme-inverse b,.theme-inverse strong,.theme-inverse .text-h1,.theme-inverse .text-h2,.theme-inverse .text-h3,.theme-inverse .text-h3_5,.theme-inverse .text-h4,.theme-inverse .text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse {background-color: #3b3d3f;color: #d7d7d9;}.card {border-radius: 3px;-webkit-box-shadow: 0 1px 1px rgba(0,0,0,0.15);box-shadow: 0 1px 1px rgba(0,0,0,0.15);}.momentum-body p {margin-bottom: 16px;margin-top: 0;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5 {color: #222326;font-weight: bold;margin-bottom: 8px;margin-top: 0;text-transform: none;}.momentum-body h1 {font-size: 40px;line-height: 48px;}.momentum-body h2 {font-size: 32px;line-height: 40px;}.momentum-body h3 {font-size: 24px;line-height: 36px;}.momentum-body h4 {font-size: 16px;letter-spacing: 0;font-family: 'Meta', sans-serif;line-height: 24px;}.momentum-body h5 {font-size: 14px;line-height: 21px;}.momentum-body small {font-size: 14px;line-height: 21px;}.momentum-body ol,.momentum-body ul {margin-bottom: 16px;margin-top: 0;padding-left: 16px;}.momentum-body ol ol,.momentum-body ul ol,.momentum-body ol ul,.momentum-body ul ul {margin-bottom: 0;}.momentum-body b,.momentum-body strong {font-weight: bolder;}.momentum-body a {-webkit-text-decoration-skip: objects;background-color: transparent;color: inherit;text-decoration: underline;}.momentum-body a:visited {color: inherit;}.momentum-body a:hover {color: #0068b3;}.momentum-body a:active {color: #003459;}.momentum-body a.strikethrough {text-decoration: line-through;}.momentum-body a.text-muted {color: #555659;}.momentum-body a.text-decoration-none {text-decoration: none;}.momentum-body a.underline-on-hover {text-decoration: none;}.momentum-body a.underline-on-hover:hover,.momentum-body a.underline-on-hover:active,.momentum-body a.underline-on-hover:focus {text-decoration: underline;}.momentum-body hr {background: #e3e4e6;border: none;height: 1px;margin-bottom: 4px;margin-top: 3px;}.momentum-body section {margin-bottom: 32px;}.momentum-body input[type=text] {height: auto;}.momentum-body button {cursor: pointer;}.momentum-body .icon {display: inline-block;height: 16px;margin-left: 8px;margin-right: 8px;width: 16px;}.momentum-body .icon:not(.icon-ms-teams) > path {fill: currentColor;}.momentum-body .icon:first-child {margin-left: 0;}.momentum-body .icon:last-child {margin-right: 0;}.momentum-body .icon-large {height: 24px;margin-left: 8px;margin-right: 8px;width: 24px;}.momentum-body .icon-small {height: 14px;width: 14px;margin-left: 8px;margin-right: 8px;}.momentum-body .icon-caption {height: 12px;width: 12px;margin-left: 4px;margin-right: 4px;}.momentum-body .icon-thumbnail {height: 48px;margin-left: $iconThumbnailMarginX;margin-right: $iconThumbnailMarginX;width: 48px;}.badge {border-radius: 3px;display: inline-block;font-size: 14px;height: 20px;line-height: 20px;margin-left: 8px;margin-right: 8px;min-width: 20px;padding-left: 4px;padding-right: 4px;text-align: center;}.badge:first-child {margin-left: 0;}.badge:last-child {margin-right: 0;}.badge {background-color: #e3e4e6;color: #969799;}.theme-inverse .badge {background-color: #555659;color: #d7d7d9;}.theme-inverse .badge.badge-default {background-color: #e3e4e6;color: #969799;}.badge.badge-primary {background-color: #0c92f3;color: #fff;}.badge.badge-secondary {background-color: #969799;color: #fff;}.badge.badge-positive {background-color: #39bf71;color: #fff;}.badge.badge-negative {background-color: #d94141;color: #fff;}.badge.badge-inverse {background-color: #555659;color: #d7d7d9;}.badge.badge-white {background-color: #fff;color: #555659;}.badge.badge-gray {background-color: #969799;color: #fff;}.badge.badge-black {background-color: #000;color: #fff;}.badge.badge-small {font-size: 12px;height: 18px;line-height: 18px;min-width: 18px;}.badge.badge-caption {font-size: 12px;height: 16px;line-height: 16px;min-width: 16px;}.button,a.button {background-color: #fff;background-image: -webkit-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -moz-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -o-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -ms-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);border: 1px solid rgba(215,215,217,0.7);color: #555659;padding: 7px 15px;}.button:hover,a.button:hover,.button.hover,a.button.hover {background-color: #fff;border-color: #b1b1b3;color: #555659;}.button:focus,a.button:focus,.button.focus,a.button.focus {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.button:active,a.button:active,.button.active,a.button.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #222326;}.button.selected,a.button.selected {background-color: #e3e4e6;color: #222326;}.button[disabled],a.button[disabled],.button.disabled,a.button.disabled {cursor: not-allowed;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.button[disabled]:hover,a.button[disabled]:hover,.button.disabled:hover,a.button.disabled:hover,.button[disabled]:active,a.button[disabled]:active,.button.disabled:active,a.button.disabled:active {background-color: #fff;background-image: $buttonBackgroundGradient;border-color: rgba(215,215,217,0.7);color: #555659;}.button.button-square,a.button.button-square {padding: 7px 11px;}.button.button-lg,a.button.button-lg {padding: 5px 15px;}.button.button-lg.button-square,a.button.button-lg.button-square {padding: 5px 14px;}.button.button-sm,a.button.button-sm {padding: 3px 15px;}.button.button-sm.button-square,a.button.button-sm.button-square {padding: 3px 8px;}.button-group .button:hover,.button-group a.button:hover {border-right-width: 1px;}.button-group .button:hover + .button,.button-group a.button:hover + .button {margin-left: 0;border-left-width: 0;}.button {border-radius: 3px;cursor: pointer;display: inline-block;font-size: 14px;line-height: 24px;margin-right: 8px;text-align: center;-webkit-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;}.button,.momentum-body .button {text-decoration: none;}.button:last-child {margin-right: 0;}.button .icon {margin-left: 12px;margin-right: 12px;opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);-webkit-transition: opacity 0.15s ease-in-out;-moz-transition: opacity 0.15s ease-in-out;-o-transition: opacity 0.15s ease-in-out;-ms-transition: opacity 0.15s ease-in-out;transition: opacity 0.15s ease-in-out;}.button .icon:first-child {margin-left: 0;}.button .icon:last-child {margin-right: 0;}.theme-inverse .button {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.theme-inverse .button .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button:visited {color: #fff;}.theme-inverse .button:hover,.theme-inverse .button.hover {background-color: #707173;border-color: #969799;color: #fff;}.theme-inverse .button:hover .icon,.theme-inverse .button.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.theme-inverse .button:active,.theme-inverse .button.active {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button.selected {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button[disabled]:hover,.theme-inverse .button.disabled:hover,.theme-inverse .button[disabled]:active,.theme-inverse .button.disabled:active {background-color: #555659;background-image: none;color: #fff;}.theme-inverse .button[disabled]:hover .icon,.theme-inverse .button.disabled:hover .icon,.theme-inverse .button[disabled]:active .icon,.theme-inverse .button.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button.button-square {padding: 8px 12px;}.theme-inverse .button.button-lg {padding: 6px 16px;}.theme-inverse .button.button-lg.button-square {padding: 6px 15px;}.theme-inverse .button.button-sm {padding: 4px 16px;}.theme-inverse .button.button-sm.button-square {padding: 4px 9px;}.button-group .theme-inverse .button:hover {border-right-width: 0;}.button-group .theme-inverse .button:hover + .button {margin-left: -1px;border-left-width: 1px;}.theme-inverse .button.button-link {border: none;background-color: transparent;background-image: none;color: #969799;padding: 0;text-decoration: underline;text-transform: none;}.theme-inverse .button.button-link:visited {color: #969799;}.theme-inverse .button.button-link:hover {color: #d7d7d9;}.theme-inverse .button.button-link:active {color: #0c92f3;}.theme-inverse .button.button-link.text-decoration-none {text-decoration: none;}.button.button-link {border: none;background-color: transparent;background-image: none;color: inherit;padding: 0;text-decoration: underline;text-transform: none;}.button.button-link:visited {color: inherit;}.button.button-link:hover {color: #0068b3;border: none;background-color: transparent;background-image: none;}.button.button-link:active {color: #003459;}.button.button-link.text-decoration-none {text-decoration: none;}.button.button-primary,.button.button-blue {background-color: #0c92f3;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-primary .icon,.button.button-blue .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:visited,.button.button-blue:visited {color: #fff;}.button.button-primary:hover,.button.button-blue:hover,.button.button-primary.hover,.button.button-blue.hover {background-color: #007fd9;border-color: #fff;color: #fff;}.button.button-primary:hover .icon,.button.button-blue:hover .icon,.button.button-primary.hover .icon,.button.button-blue.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:active,.button.button-blue:active,.button.button-primary.active,.button.button-blue.active {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary.selected,.button.button-blue.selected {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary[disabled]:hover,.button.button-blue[disabled]:hover,.button.button-primary.disabled:hover,.button.button-blue.disabled:hover,.button.button-primary[disabled]:active,.button.button-blue[disabled]:active,.button.button-primary.disabled:active,.button.button-blue.disabled:active {background-color: #0c92f3;background-image: none;color: #fff;}.button.button-primary[disabled]:hover .icon,.button.button-blue[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-blue.disabled:hover .icon,.button.button-primary[disabled]:active .icon,.button.button-blue[disabled]:active .icon,.button.button-primary.disabled:active .icon,.button.button-blue.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary.button-square,.button.button-blue.button-square {padding: 8px 12px;}.button.button-primary.button-lg,.button.button-blue.button-lg {padding: 6px 16px;}.button.button-primary.button-lg.button-square,.button.button-blue.button-lg.button-square {padding: 6px 15px;}.button.button-primary.button-sm,.button.button-blue.button-sm {padding: 4px 16px;}.button.button-primary.button-sm.button-square,.button.button-blue.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary:hover,.button-group .button.button-blue:hover {border-right-width: 0;}.button-group .button.button-primary:hover + .button,.button-group .button.button-blue:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-primary[disabled],.button.button-primary.disabled {background-color: #e3e4e6;background-image: none;border-color: #d7d7d9;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-primary[disabled] .icon,.button.button-primary.disabled .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled]:visited,.button.button-primary.disabled:visited {color: #555659;}.button.button-primary[disabled]:hover,.button.button-primary.disabled:hover,.button.button-primary[disabled].hover,.button.button-primary.disabled.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-primary[disabled].hover .icon,.button.button-primary.disabled.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary[disabled]:active,.button.button-primary.disabled:active,.button.button-primary[disabled].active,.button.button-primary.disabled.active {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled].selected,.button.button-primary.disabled.selected {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled][disabled]:hover,.button.button-primary.disabled[disabled]:hover,.button.button-primary[disabled].disabled:hover,.button.button-primary.disabled.disabled:hover,.button.button-primary[disabled][disabled]:active,.button.button-primary.disabled[disabled]:active,.button.button-primary[disabled].disabled:active,.button.button-primary.disabled.disabled:active {background-color: #e3e4e6;background-image: none;color: #555659;}.button.button-primary[disabled][disabled]:hover .icon,.button.button-primary.disabled[disabled]:hover .icon,.button.button-primary[disabled].disabled:hover .icon,.button.button-primary.disabled.disabled:hover .icon,.button.button-primary[disabled][disabled]:active .icon,.button.button-primary.disabled[disabled]:active .icon,.button.button-primary[disabled].disabled:active .icon,.button.button-primary.disabled.disabled:active .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled].button-square,.button.button-primary.disabled.button-square {padding: 8px 12px;}.button.button-primary[disabled].button-lg,.button.button-primary.disabled.button-lg {padding: 6px 16px;}.button.button-primary[disabled].button-lg.button-square,.button.button-primary.disabled.button-lg.button-square {padding: 6px 15px;}.button.button-primary[disabled].button-sm,.button.button-primary.disabled.button-sm {padding: 4px 16px;}.button.button-primary[disabled].button-sm.button-square,.button.button-primary.disabled.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary[disabled]:hover,.button-group .button.button-primary.disabled:hover {border-right-width: 0;}.button-group .button.button-primary[disabled]:hover + .button,.button-group .button.button-primary.disabled:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-positive,.button.button-green {background-color: #39bf71;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-positive .icon,.button.button-green .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:visited,.button.button-green:visited {color: #fff;}.button.button-positive:hover,.button.button-green:hover,.button.button-positive.hover,.button.button-green.hover {background-color: #19a654;border-color: #fff;color: #fff;}.button.button-positive:hover .icon,.button.button-green:hover .icon,.button.button-positive.hover .icon,.button.button-green.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:active,.button.button-green:active,.button.button-positive.active,.button.button-green.active {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive.selected,.button.button-green.selected {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive[disabled]:hover,.button.button-green[disabled]:hover,.button.button-positive.disabled:hover,.button.button-green.disabled:hover,.button.button-positive[disabled]:active,.button.button-green[disabled]:active,.button.button-positive.disabled:active,.button.button-green.disabled:active {background-color: #39bf71;background-image: none;color: #fff;}.button.button-positive[disabled]:hover .icon,.button.button-green[disabled]:hover .icon,.button.button-positive.disabled:hover .icon,.button.button-green.disabled:hover .icon,.button.button-positive[disabled]:active .icon,.button.button-green[disabled]:active .icon,.button.button-positive.disabled:active .icon,.button.button-green.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive.button-square,.button.button-green.button-square {padding: 8px 12px;}.button.button-positive.button-lg,.button.button-green.button-lg {padding: 6px 16px;}.button.button-positive.button-lg.button-square,.button.button-green.button-lg.button-square {padding: 6px 15px;}.button.button-positive.button-sm,.button.button-green.button-sm {padding: 4px 16px;}.button.button-positive.button-sm.button-square,.button.button-green.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-positive:hover,.button-group .button.button-green:hover {border-right-width: 0;}.button-group .button.button-positive:hover + .button,.button-group .button.button-green:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-negative,.button.button-red {background-color: #d94141;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-negative .icon,.button.button-red .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:visited,.button.button-red:visited {color: #fff;}.button.button-negative:hover,.button.button-red:hover,.button.button-negative.hover,.button.button-red.hover {background-color: #bf3939;border-color: #fff;color: #fff;}.button.button-negative:hover .icon,.button.button-red:hover .icon,.button.button-negative.hover .icon,.button.button-red.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:active,.button.button-red:active,.button.button-negative.active,.button.button-red.active {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative.selected,.button.button-red.selected {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative[disabled]:hover,.button.button-red[disabled]:hover,.button.button-negative.disabled:hover,.button.button-red.disabled:hover,.button.button-negative[disabled]:active,.button.button-red[disabled]:active,.button.button-negative.disabled:active,.button.button-red.disabled:active {background-color: #d94141;background-image: none;color: #fff;}.button.button-negative[disabled]:hover .icon,.button.button-red[disabled]:hover .icon,.button.button-negative.disabled:hover .icon,.button.button-red.disabled:hover .icon,.button.button-negative[disabled]:active .icon,.button.button-red[disabled]:active .icon,.button.button-negative.disabled:active .icon,.button.button-red.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative.button-square,.button.button-red.button-square {padding: 8px 12px;}.button.button-negative.button-lg,.button.button-red.button-lg {padding: 6px 16px;}.button.button-negative.button-lg.button-square,.button.button-red.button-lg.button-square {padding: 6px 15px;}.button.button-negative.button-sm,.button.button-red.button-sm {padding: 4px 16px;}.button.button-negative.button-sm.button-square,.button.button-red.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-negative:hover,.button-group .button.button-red:hover {border-right-width: 0;}.button-group .button.button-negative:hover + .button,.button-group .button.button-red:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-inverse,.button.button-gray {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-inverse .icon,.button.button-gray .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse:visited,.button.button-gray:visited {color: #fff;}.button.button-inverse:hover,.button.button-gray:hover,.button.button-inverse.hover,.button.button-gray.hover {background-color: #707173;border-color: #969799;color: #fff;}.button.button-inverse:hover .icon,.button.button-gray:hover .icon,.button.button-inverse.hover .icon,.button.button-gray.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-inverse:active,.button.button-gray:active,.button.button-inverse.active,.button.button-gray.active {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse.selected,.button.button-gray.selected {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse[disabled]:hover,.button.button-gray[disabled]:hover,.button.button-inverse.disabled:hover,.button.button-gray.disabled:hover,.button.button-inverse[disabled]:active,.button.button-gray[disabled]:active,.button.button-inverse.disabled:active,.button.button-gray.disabled:active {background-color: #555659;background-image: none;color: #fff;}.button.button-inverse[disabled]:hover .icon,.button.button-gray[disabled]:hover .icon,.button.button-inverse.disabled:hover .icon,.button.button-gray.disabled:hover .icon,.button.button-inverse[disabled]:active .icon,.button.button-gray[disabled]:active .icon,.button.button-inverse.disabled:active .icon,.button.button-gray.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse.button-square,.button.button-gray.button-square {padding: 8px 12px;}.button.button-inverse.button-lg,.button.button-gray.button-lg {padding: 6px 16px;}.button.button-inverse.button-lg.button-square,.button.button-gray.button-lg.button-square {padding: 6px 15px;}.button.button-inverse.button-sm,.button.button-gray.button-sm {padding: 4px 16px;}.button.button-inverse.button-sm.button-square,.button.button-gray.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-inverse:hover,.button-group .button.button-gray:hover {border-right-width: 0;}.button-group .button.button-inverse:hover + .button,.button-group .button.button-gray:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet {background-color: #a452cc;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-violet .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:visited {color: #fff;}.button.button-violet:hover,.button.button-violet.hover {background-color: #9c2bd4;border-color: #fff;color: #fff;}.button.button-violet:hover .icon,.button.button-violet.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:active,.button.button-violet.active {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet.selected {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet[disabled]:hover,.button.button-violet.disabled:hover,.button.button-violet[disabled]:active,.button.button-violet.disabled:active {background-color: #a452cc;background-image: none;color: #fff;}.button.button-violet[disabled]:hover .icon,.button.button-violet.disabled:hover .icon,.button.button-violet[disabled]:active .icon,.button.button-violet.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet.button-square {padding: 8px 12px;}.button.button-violet.button-lg {padding: 6px 16px;}.button.button-violet.button-lg.button-square {padding: 6px 15px;}.button.button-violet.button-sm {padding: 4px 16px;}.button.button-violet.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet:hover {border-right-width: 0;}.button-group .button.button-violet:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet-light {background-color: #f5e0ff;background-image: none;border-color: #f5e0ff;border-width: 0;color: #620e8c;padding: 8px 16px;}.button.button-violet-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light:visited {color: #620e8c;}.button.button-violet-light:hover,.button.button-violet-light.hover {background-color: #ebc4ff;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light:hover .icon,.button.button-violet-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet-light:active,.button.button-violet-light.active {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light.selected {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light[disabled]:hover,.button.button-violet-light.disabled:hover,.button.button-violet-light[disabled]:active,.button.button-violet-light.disabled:active {background-color: #f5e0ff;background-image: none;color: #620e8c;}.button.button-violet-light[disabled]:hover .icon,.button.button-violet-light.disabled:hover .icon,.button.button-violet-light[disabled]:active .icon,.button.button-violet-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light.button-square {padding: 8px 12px;}.button.button-violet-light.button-lg {padding: 6px 16px;}.button.button-violet-light.button-lg.button-square {padding: 6px 15px;}.button.button-violet-light.button-sm {padding: 4px 16px;}.button.button-violet-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet-light:hover {border-right-width: 0;}.button-group .button.button-violet-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-blue-light {background-color: #e1f3ff;background-image: none;border-color: #e1f3ff;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-blue-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light:visited {color: #555659;}.button.button-blue-light:hover,.button.button-blue-light.hover {background-color: #bfe5ff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light:hover .icon,.button.button-blue-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-blue-light:active,.button.button-blue-light.active {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light.selected {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light[disabled]:hover,.button.button-blue-light.disabled:hover,.button.button-blue-light[disabled]:active,.button.button-blue-light.disabled:active {background-color: #e1f3ff;background-image: none;color: #555659;}.button.button-blue-light[disabled]:hover .icon,.button.button-blue-light.disabled:hover .icon,.button.button-blue-light[disabled]:active .icon,.button.button-blue-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light.button-square {padding: 8px 12px;}.button.button-blue-light.button-lg {padding: 6px 16px;}.button.button-blue-light.button-lg.button-square {padding: 6px 15px;}.button.button-blue-light.button-sm {padding: 4px 16px;}.button.button-blue-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-blue-light:hover {border-right-width: 0;}.button-group .button.button-blue-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-turquoise {background-color: #1cadba;background-image: none;border-color: #1cadba;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-turquoise .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise:visited {color: #555659;}.button.button-turquoise:hover,.button.button-turquoise.hover {background-color: #0097a6;border-color: #1cadba;color: #555659;}.button.button-turquoise:hover .icon,.button.button-turquoise.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-turquoise:active,.button.button-turquoise.active {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise.selected {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise[disabled]:hover,.button.button-turquoise.disabled:hover,.button.button-turquoise[disabled]:active,.button.button-turquoise.disabled:active {background-color: #1cadba;background-image: none;color: #555659;}.button.button-turquoise[disabled]:hover .icon,.button.button-turquoise.disabled:hover .icon,.button.button-turquoise[disabled]:active .icon,.button.button-turquoise.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise.button-square {padding: 8px 12px;}.button.button-turquoise.button-lg {padding: 6px 16px;}.button.button-turquoise.button-lg.button-square {padding: 6px 15px;}.button.button-turquoise.button-sm {padding: 4px 16px;}.button.button-turquoise.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-turquoise:hover {border-right-width: 0;}.button-group .button.button-turquoise:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-yellow {background-color: #ffa60d;background-image: none;border-color: #ffa60d;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-yellow .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow:visited {color: #fff;}.button.button-yellow:hover,.button.button-yellow.hover {background-color: #ff9000;border-color: #ffa60d;color: #fff;}.button.button-yellow:hover .icon,.button.button-yellow.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-yellow:active,.button.button-yellow.active {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow.selected {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow[disabled]:hover,.button.button-yellow.disabled:hover,.button.button-yellow[disabled]:active,.button.button-yellow.disabled:active {background-color: #ffa60d;background-image: none;color: #fff;}.button.button-yellow[disabled]:hover .icon,.button.button-yellow.disabled:hover .icon,.button.button-yellow[disabled]:active .icon,.button.button-yellow.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow.button-square {padding: 8px 12px;}.button.button-yellow.button-lg {padding: 6px 16px;}.button.button-yellow.button-lg.button-square {padding: 6px 15px;}.button.button-yellow.button-sm {padding: 4px 16px;}.button.button-yellow.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-yellow:hover {border-right-width: 0;}.button-group .button.button-yellow:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-black {background-color: #000;background-image: none;border-color: #000;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-black .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black:visited {color: #fff;}.button.button-black:hover,.button.button-black.hover {background-color: #3b3d3f;border-color: #000;color: #fff;}.button.button-black:hover .icon,.button.button-black.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-black:active,.button.button-black.active {background-color: #555659;border-color: #000;color: #fff;}.button.button-black.selected {background-color: #555659;border-color: #000;color: #fff;}.button.button-black[disabled]:hover,.button.button-black.disabled:hover,.button.button-black[disabled]:active,.button.button-black.disabled:active {background-color: #000;background-image: none;color: #fff;}.button.button-black[disabled]:hover .icon,.button.button-black.disabled:hover .icon,.button.button-black[disabled]:active .icon,.button.button-black.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black.button-square {padding: 8px 12px;}.button.button-black.button-lg {padding: 6px 16px;}.button.button-black.button-lg.button-square {padding: 6px 15px;}.button.button-black.button-sm {padding: 4px 16px;}.button.button-black.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-black:hover {border-right-width: 0;}.button-group .button.button-black:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-lg {border-radius: 3px;font-size: 18px;line-height: 36px;}.button.button-lg .icon,.momentum-body .button.button-lg .icon {height: 18px;width: 18px;}.button.button-sm {border-radius: 3px;font-size: 14px;line-height: 24px;}.button.button-sm .icon,.momentum-body .button.button-sm .icon {height: 14px;width: 14px;}.button-group {margin-right: 8px;}.button-group:last-child {margin-right: 0;}.button-group .button {border-radius: 0;margin-right: 0;}.button-group .button:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.button-group .button:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.button-group .button + .button {border-left-width: 1px;margin-left: -1px;}.button-circle {border-radius: 50%;background-color: #fff;border: 0;padding: 12px 0;color: #969799;height: 46px;width: 46px;line-height: 23px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.button-circle >.icon {height: 23px;width: 23px;margin: auto;}.button-circle:hover {color: #fff;background-color: #0c92f3;}.button-circle,a.button-circle {display: inline-block;background: #fff;}.button-circle,.momentum-body .button-circle {text-decoration: none;}.button-circle.button-shadow {-webkit-box-shadow: 0px 1px 4px rgba(0,0,0,0.25);box-shadow: 0px 1px 4px rgba(0,0,0,0.25);}.button-circle.button-circle-sm {height: 28px;width: 28px;line-height: 14px;padding: 6px 7px 6px 5px;}.button-circle.button-circle-sm >.icon {height: 14px;width: 14px;}.button-circle.button-circle-lg {height: 56px;width: 56px;line-height: 28px;padding: 13px 0;}.button-circle.button-circle-lg >.icon {height: 28px;width: 28px;}.card {background-color: #fff;border: 1px solid #f0f1f2;padding: 16px;width: 100%;}.centered-content {align-items: center;display: flex;justify-content: center;}.ol-chain-list {padding: 8px 16px;border-radius: 3px;}.ol-chain-list .ol-chain-separator:not(:last-child) {border-bottom: 1px solid #d7d7d9;border-color: #d7d7d9;}.ol-chain-list .ol-chain-link {position: relative;padding: 8px 0;margin-left: 40px;}.ol-chain-list .ol-chain-link:before {position: absolute;top: 8px;bottom: -8px;border-color: #d7d7d9;border-style: dashed;border-width: 0 0 0 1px;content: "";left: -28px;}.ol-chain-list .ol-chain-link:last-child:before {display: none;}.ol-chain-list .ol-chain-link .ol-chain-counter {border: 1px solid #d7d7d9;border-radius: 50%;}.ol-chain-list .ol-chain-link .ol-chain-icon {align-items: center;display: flex;justify-content: center;padding-bottom: 4px;padding-top: 4px;}.ol-chain-list .ol-chain-link .ol-chain-counter,.ol-chain-list .ol-chain-link .ol-chain-icon {position: absolute;left: -40px;width: 24px;height: 24px;background: #fff;text-align: center;font-size: 14px;}.ol-chain-list .ol-chain-link .ol-chain-counter.optional,.ol-chain-list .ol-chain-link .ol-chain-icon.optional {border: 1px dotted #d7d7d9;}.ol-chain-list .ol-chain-link .ol-chain-content {width: 70%;}.ol-chain-list .ol-chain-link .ol-chain-content-100 {width: 100%;}.ol-chain-list .ol-chain-link .ol-chain-content-distributed {display: flex;justify-content: space-between;}.chip {border-radius: 12px;border-style: solid;border-width: 1px;display: inline-block;font-size: 14px;line-height: 14px;height: 24px;margin: 1px 4px 3px;max-width: 100%;overflow: hidden;padding: 4px 7px;-o-text-overflow: ellipsis;text-overflow: ellipsis;-webkit-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-moz-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-o-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-ms-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;vertical-align: middle;white-space: nowrap;}.chip,.momentum-body .chip {text-decoration: none;}.chip.chip-box {border-radius: 3px;}.chip:first-child {margin-left: 0;}.chip:last-child {margin-right: 0;}.chip + .chip {margin-left: 0;}.chip .icon {height: 1em;width: 1em;}.chip .icon,.chip .icon.momentum-body {margin-left: 0.5em;margin-right: 0.5em;}.chip > .close {color: inherit;}.chip > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 8px;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip > .close:hover {color: inherit;}.chip > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip > .close:active {color: inherit;}.chip > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip,.momentum-body  .chip {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}a.chip:hover,button.chip:hover,.chip.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}a.chip:active,button.chip:active,.chip.active {background-color: #b1b1b3;border-color: #b1b1b3;color: #555659;}a.chip:focus,button.chip:focus,.chip.focus {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip[disabled],.chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip[disabled]:hover,.chip.disabled:hover,.chip[disabled]:active,.chip.disabled:active {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined,.momentum-body  .chip.chip-outlined {background-color: #fff;border-color: #e3e4e6;color: #555659;}a.chip.chip-outlined:hover,button.chip.chip-outlined:hover,.chip.chip-outlined.hover {background-color: #f0f1f2;border-color: #d7d7d9;color: #555659;}a.chip.chip-outlined:active,button.chip.chip-outlined:active,.chip.chip-outlined.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #555659;}a.chip.chip-outlined:focus,button.chip.chip-outlined:focus,.chip.chip-outlined.focus {background-color: #fff;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined[disabled],.chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-outlined[disabled]:hover,.chip.chip-outlined.disabled:hover,.chip.chip-outlined[disabled]:active,.chip.chip-outlined.disabled:active {background-color: #fff;border-color: #e3e4e6;color: #555659;}.theme-inverse .chip,.momentum-body .theme-inverse .chip {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse a.chip:hover,.theme-inverse button.chip:hover,.theme-inverse .chip.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}.theme-inverse a.chip:active,.theme-inverse button.chip:active,.theme-inverse .chip.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip:focus,.theme-inverse button.chip:focus,.theme-inverse .chip.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip[disabled],.theme-inverse .chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip[disabled]:hover,.theme-inverse .chip.disabled:hover,.theme-inverse .chip[disabled]:active,.theme-inverse .chip.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip.chip-outlined,.momentum-body .theme-inverse .chip.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse a.chip.chip-outlined:hover,.theme-inverse button.chip.chip-outlined:hover,.theme-inverse .chip.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:active,.theme-inverse button.chip.chip-outlined:active,.theme-inverse .chip.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:focus,.theme-inverse button.chip.chip-outlined:focus,.theme-inverse .chip.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse .chip.chip-outlined[disabled],.theme-inverse .chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip.chip-outlined[disabled]:hover,.theme-inverse .chip.chip-outlined.disabled:hover,.theme-inverse .chip.chip-outlined[disabled]:active,.theme-inverse .chip.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse,.momentum-body  .chip.chip-inverse {background-color: #555659;border-color: #555659;color: #f0f1f2;}a.chip.chip-inverse:hover,button.chip.chip-inverse:hover,.chip.chip-inverse.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}a.chip.chip-inverse:active,button.chip.chip-inverse:active,.chip.chip-inverse.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse:focus,button.chip.chip-inverse:focus,.chip.chip-inverse.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse[disabled],.chip.chip-inverse.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse[disabled]:hover,.chip.chip-inverse.disabled:hover,.chip.chip-inverse[disabled]:active,.chip.chip-inverse.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse.chip-outlined,.momentum-body  .chip.chip-inverse.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}a.chip.chip-inverse.chip-outlined:hover,button.chip.chip-inverse.chip-outlined:hover,.chip.chip-inverse.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:active,button.chip.chip-inverse.chip-outlined:active,.chip.chip-inverse.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:focus,button.chip.chip-inverse.chip-outlined:focus,.chip.chip-inverse.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse.chip-outlined[disabled],.chip.chip-inverse.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse.chip-outlined[disabled]:hover,.chip.chip-inverse.chip-outlined.disabled:hover,.chip.chip-inverse.chip-outlined[disabled]:active,.chip.chip-inverse.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-blue,.momentum-body  .chip.chip-blue {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}a.chip.chip-blue:hover,button.chip.chip-blue:hover,.chip.chip-blue.hover {background-color: #bfe5ff;border-color: #bfe5ff;color: #555659;}a.chip.chip-blue:active,button.chip.chip-blue:active,.chip.chip-blue.active {background-color: #a6daff;border-color: #a6daff;color: #555659;}a.chip.chip-blue:focus,button.chip.chip-blue:focus,.chip.chip-blue.focus {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue[disabled],.chip.chip-blue.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue[disabled]:hover,.chip.chip-blue.disabled:hover,.chip.chip-blue[disabled]:active,.chip.chip-blue.disabled:active {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue.chip-outlined,.momentum-body  .chip.chip-blue.chip-outlined {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:hover,button.chip.chip-blue.chip-outlined:hover,.chip.chip-blue.chip-outlined.hover {background-color: #bfe5ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:active,button.chip.chip-blue.chip-outlined:active,.chip.chip-blue.chip-outlined.active {background-color: #a6daff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:focus,button.chip.chip-blue.chip-outlined:focus,.chip.chip-blue.chip-outlined.focus {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue.chip-outlined[disabled],.chip.chip-blue.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue.chip-outlined[disabled]:hover,.chip.chip-blue.chip-outlined.disabled:hover,.chip.chip-blue.chip-outlined[disabled]:active,.chip.chip-blue.chip-outlined.disabled:active {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue-dark,.momentum-body  .chip.chip-blue-dark {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}a.chip.chip-blue-dark:hover,button.chip.chip-blue-dark:hover,.chip.chip-blue-dark.hover {background-color: #0068b3;border-color: #0068b3;color: #f3faff;}a.chip.chip-blue-dark:active,button.chip.chip-blue-dark:active,.chip.chip-blue-dark.active {background-color: #004a7f;border-color: #004a7f;color: #f3faff;}a.chip.chip-blue-dark:focus,button.chip.chip-blue-dark:focus,.chip.chip-blue-dark.focus {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark[disabled],.chip.chip-blue-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark[disabled]:hover,.chip.chip-blue-dark.disabled:hover,.chip.chip-blue-dark[disabled]:active,.chip.chip-blue-dark.disabled:active {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark.chip-outlined,.momentum-body  .chip.chip-blue-dark.chip-outlined {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:hover,button.chip.chip-blue-dark.chip-outlined:hover,.chip.chip-blue-dark.chip-outlined.hover {background-color: #0068b3;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:active,button.chip.chip-blue-dark.chip-outlined:active,.chip.chip-blue-dark.chip-outlined.active {background-color: #004a7f;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:focus,button.chip.chip-blue-dark.chip-outlined:focus,.chip.chip-blue-dark.chip-outlined.focus {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-blue-dark.chip-outlined[disabled],.chip.chip-blue-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark.chip-outlined[disabled]:hover,.chip.chip-blue-dark.chip-outlined.disabled:hover,.chip.chip-blue-dark.chip-outlined[disabled]:active,.chip.chip-blue-dark.chip-outlined.disabled:active {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-red,.momentum-body  .chip.chip-red {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}a.chip.chip-red:hover,button.chip.chip-red:hover,.chip.chip-red.hover {background-color: #ffbfbf;border-color: #ffbfbf;color: #555659;}a.chip.chip-red:active,button.chip.chip-red:active,.chip.chip-red.active {background-color: #f99;border-color: #f99;color: #555659;}a.chip.chip-red:focus,button.chip.chip-red:focus,.chip.chip-red.focus {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red[disabled],.chip.chip-red.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red[disabled]:hover,.chip.chip-red.disabled:hover,.chip.chip-red[disabled]:active,.chip.chip-red.disabled:active {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red.chip-outlined,.momentum-body  .chip.chip-red.chip-outlined {background-color: #ffe6e6;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:hover,button.chip.chip-red.chip-outlined:hover,.chip.chip-red.chip-outlined.hover {background-color: #ffbfbf;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:active,button.chip.chip-red.chip-outlined:active,.chip.chip-red.chip-outlined.active {background-color: #f99;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:focus,button.chip.chip-red.chip-outlined:focus,.chip.chip-red.chip-outlined.focus {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red.chip-outlined[disabled],.chip.chip-red.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red.chip-outlined[disabled]:hover,.chip.chip-red.chip-outlined.disabled:hover,.chip.chip-red.chip-outlined[disabled]:active,.chip.chip-red.chip-outlined.disabled:active {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red-dark,.momentum-body  .chip.chip-red-dark {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}a.chip.chip-red-dark:hover,button.chip.chip-red-dark:hover,.chip.chip-red-dark.hover {background-color: #a62929;border-color: #a62929;color: #fff7f7;}a.chip.chip-red-dark:active,button.chip.chip-red-dark:active,.chip.chip-red-dark.active {background-color: #801a1a;border-color: #801a1a;color: #fff7f7;}a.chip.chip-red-dark:focus,button.chip.chip-red-dark:focus,.chip.chip-red-dark.focus {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark[disabled],.chip.chip-red-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark[disabled]:hover,.chip.chip-red-dark.disabled:hover,.chip.chip-red-dark[disabled]:active,.chip.chip-red-dark.disabled:active {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark.chip-outlined,.momentum-body  .chip.chip-red-dark.chip-outlined {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:hover,button.chip.chip-red-dark.chip-outlined:hover,.chip.chip-red-dark.chip-outlined.hover {background-color: #a62929;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:active,button.chip.chip-red-dark.chip-outlined:active,.chip.chip-red-dark.chip-outlined.active {background-color: #801a1a;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:focus,button.chip.chip-red-dark.chip-outlined:focus,.chip.chip-red-dark.chip-outlined.focus {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-red-dark.chip-outlined[disabled],.chip.chip-red-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark.chip-outlined[disabled]:hover,.chip.chip-red-dark.chip-outlined.disabled:hover,.chip.chip-red-dark.chip-outlined[disabled]:active,.chip.chip-red-dark.chip-outlined.disabled:active {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-green,.momentum-body  .chip.chip-green {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}a.chip.chip-green:hover,button.chip.chip-green:hover,.chip.chip-green.hover {background-color: #b4f0a8;border-color: #b4f0a8;color: #555659;}a.chip.chip-green:active,button.chip.chip-green:active,.chip.chip-green.active {background-color: #8ae58a;border-color: #8ae58a;color: #555659;}a.chip.chip-green:focus,button.chip.chip-green:focus,.chip.chip-green.focus {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green[disabled],.chip.chip-green.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green[disabled]:hover,.chip.chip-green.disabled:hover,.chip.chip-green[disabled]:active,.chip.chip-green.disabled:active {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green.chip-outlined,.momentum-body  .chip.chip-green.chip-outlined {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:hover,button.chip.chip-green.chip-outlined:hover,.chip.chip-green.chip-outlined.hover {background-color: #b4f0a8;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:active,button.chip.chip-green.chip-outlined:active,.chip.chip-green.chip-outlined.active {background-color: #8ae58a;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:focus,button.chip.chip-green.chip-outlined:focus,.chip.chip-green.chip-outlined.focus {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green.chip-outlined[disabled],.chip.chip-green.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green.chip-outlined[disabled]:hover,.chip.chip-green.chip-outlined.disabled:hover,.chip.chip-green.chip-outlined[disabled]:active,.chip.chip-green.chip-outlined.disabled:active {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green-dark,.momentum-body  .chip.chip-green-dark {background-color: #19a654;border-color: #19a654;color: #e1fae5;}a.chip.chip-green-dark:hover,button.chip.chip-green-dark:hover,.chip.chip-green-dark.hover {background-color: #0e8c42;border-color: #0e8c42;color: #e1fae5;}a.chip.chip-green-dark:active,button.chip.chip-green-dark:active,.chip.chip-green-dark.active {background-color: #007343;border-color: #007343;color: #e1fae5;}a.chip.chip-green-dark:focus,button.chip.chip-green-dark:focus,.chip.chip-green-dark.focus {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark[disabled],.chip.chip-green-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark[disabled]:hover,.chip.chip-green-dark.disabled:hover,.chip.chip-green-dark[disabled]:active,.chip.chip-green-dark.disabled:active {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark.chip-outlined,.momentum-body  .chip.chip-green-dark.chip-outlined {background-color: #19a654;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:hover,button.chip.chip-green-dark.chip-outlined:hover,.chip.chip-green-dark.chip-outlined.hover {background-color: #0e8c42;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:active,button.chip.chip-green-dark.chip-outlined:active,.chip.chip-green-dark.chip-outlined.active {background-color: #007343;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:focus,button.chip.chip-green-dark.chip-outlined:focus,.chip.chip-green-dark.chip-outlined.focus {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-green-dark.chip-outlined[disabled],.chip.chip-green-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark.chip-outlined[disabled]:hover,.chip.chip-green-dark.chip-outlined.disabled:hover,.chip.chip-green-dark.chip-outlined[disabled]:active,.chip.chip-green-dark.chip-outlined.disabled:active {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-yellow,.momentum-body  .chip.chip-yellow {background-color: #fec;border-color: #fec;color: #555659;}a.chip.chip-yellow:hover,button.chip.chip-yellow:hover,.chip.chip-yellow.hover {background-color: #ffe5b2;border-color: #ffe5b2;color: #555659;}a.chip.chip-yellow:active,button.chip.chip-yellow:active,.chip.chip-yellow.active {background-color: #ffdf88;border-color: #ffdf88;color: #555659;}a.chip.chip-yellow:focus,button.chip.chip-yellow:focus,.chip.chip-yellow.focus {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow[disabled],.chip.chip-yellow.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow[disabled]:hover,.chip.chip-yellow.disabled:hover,.chip.chip-yellow[disabled]:active,.chip.chip-yellow.disabled:active {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow.chip-outlined,.momentum-body  .chip.chip-yellow.chip-outlined {background-color: #fec;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:hover,button.chip.chip-yellow.chip-outlined:hover,.chip.chip-yellow.chip-outlined.hover {background-color: #ffe5b2;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:active,button.chip.chip-yellow.chip-outlined:active,.chip.chip-yellow.chip-outlined.active {background-color: #ffdf88;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:focus,button.chip.chip-yellow.chip-outlined:focus,.chip.chip-yellow.chip-outlined.focus {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow.chip-outlined[disabled],.chip.chip-yellow.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow.chip-outlined[disabled]:hover,.chip.chip-yellow.chip-outlined.disabled:hover,.chip.chip-yellow.chip-outlined[disabled]:active,.chip.chip-yellow.chip-outlined.disabled:active {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow-dark,.momentum-body  .chip.chip-yellow-dark {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}a.chip.chip-yellow-dark:hover,button.chip.chip-yellow-dark:hover,.chip.chip-yellow-dark.hover {background-color: #e67600;border-color: #e67600;color: #fff6e5;}a.chip.chip-yellow-dark:active,button.chip.chip-yellow-dark:active,.chip.chip-yellow-dark.active {background-color: #cc5f00;border-color: #cc5f00;color: #fff6e5;}a.chip.chip-yellow-dark:focus,button.chip.chip-yellow-dark:focus,.chip.chip-yellow-dark.focus {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark[disabled],.chip.chip-yellow-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark[disabled]:hover,.chip.chip-yellow-dark.disabled:hover,.chip.chip-yellow-dark[disabled]:active,.chip.chip-yellow-dark.disabled:active {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined,.momentum-body  .chip.chip-yellow-dark.chip-outlined {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:hover,button.chip.chip-yellow-dark.chip-outlined:hover,.chip.chip-yellow-dark.chip-outlined.hover {background-color: #e67600;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:active,button.chip.chip-yellow-dark.chip-outlined:active,.chip.chip-yellow-dark.chip-outlined.active {background-color: #cc5f00;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:focus,button.chip.chip-yellow-dark.chip-outlined:focus,.chip.chip-yellow-dark.chip-outlined.focus {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined[disabled],.chip.chip-yellow-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark.chip-outlined[disabled]:hover,.chip.chip-yellow-dark.chip-outlined.disabled:hover,.chip.chip-yellow-dark.chip-outlined[disabled]:active,.chip.chip-yellow-dark.chip-outlined.disabled:active {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-violet,.momentum-body  .chip.chip-violet {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}a.chip.chip-violet:hover,button.chip.chip-violet:hover,.chip.chip-violet.hover {background-color: #ebc4ff;border-color: #ebc4ff;color: #555659;}a.chip.chip-violet:active,button.chip.chip-violet:active,.chip.chip-violet.active {background-color: #dea2fc;border-color: #dea2fc;color: #555659;}a.chip.chip-violet:focus,button.chip.chip-violet:focus,.chip.chip-violet.focus {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet[disabled],.chip.chip-violet.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet[disabled]:hover,.chip.chip-violet.disabled:hover,.chip.chip-violet[disabled]:active,.chip.chip-violet.disabled:active {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet.chip-outlined,.momentum-body  .chip.chip-violet.chip-outlined {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:hover,button.chip.chip-violet.chip-outlined:hover,.chip.chip-violet.chip-outlined.hover {background-color: #ebc4ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:active,button.chip.chip-violet.chip-outlined:active,.chip.chip-violet.chip-outlined.active {background-color: #dea2fc;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:focus,button.chip.chip-violet.chip-outlined:focus,.chip.chip-violet.chip-outlined.focus {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-violet.chip-outlined[disabled],.chip.chip-violet.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet.chip-outlined[disabled]:hover,.chip.chip-violet.chip-outlined.disabled:hover,.chip.chip-violet.chip-outlined[disabled]:active,.chip.chip-violet.chip-outlined.disabled:active {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-turquoise,.momentum-body  .chip.chip-turquoise {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}a.chip.chip-turquoise:hover,button.chip.chip-turquoise:hover,.chip.chip-turquoise.hover {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise:active,button.chip.chip-turquoise:active,.chip.chip-turquoise.active {background-color: #91eaf2;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise:focus,button.chip.chip-turquoise:focus,.chip.chip-turquoise.focus {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise[disabled],.chip.chip-turquoise.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise[disabled]:hover,.chip.chip-turquoise.disabled:hover,.chip.chip-turquoise[disabled]:active,.chip.chip-turquoise.disabled:active {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}.chip.chip-turquoise.chip-outlined,.momentum-body  .chip.chip-turquoise.chip-outlined {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise.chip-outlined:hover,button.chip.chip-turquoise.chip-outlined:hover,.chip.chip-turquoise.chip-outlined.hover {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise.chip-outlined:active,button.chip.chip-turquoise.chip-outlined:active,.chip.chip-turquoise.chip-outlined.active {background-color: #91eaf2;border-color: #33c0cd;color: #222326;}a.chip.chip-turquoise.chip-outlined:focus,button.chip.chip-turquoise.chip-outlined:focus,.chip.chip-turquoise.chip-outlined.focus {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}.chip.chip-turquoise.chip-outlined[disabled],.chip.chip-turquoise.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise.chip-outlined[disabled]:hover,.chip.chip-turquoise.chip-outlined.disabled:hover,.chip.chip-turquoise.chip-outlined[disabled]:active,.chip.chip-turquoise.chip-outlined.disabled:active {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise.closable.closable-wide > .close::after {color: #555659;}.chip.chip-turquoise.closable.closable-wide > .close:hover::after {background-color: #91eaf2;}.chip.chip-turquoise.closable.closable-wide > .close:active::after {background-color: #33c0cd;}.chip.chip-lg {border-radius: 16px;font-size: 16px;height: 32px;line-height: 16px;padding: 7px 11px;}.chip.chip-lg.chip-box {border-radius: 3px;}.chip.chip-lg > .close::after {font-size: 13px;margin-left: 8px;}.chip.chip-sm {border-radius: 8px;font-size: 12px;height: 16px;line-height: 12px;padding: 1px 7px;}.chip.chip-sm.chip-box {border-radius: 3px;}.chip.chip-sm > .close::after {font-size: 9px;margin-left: 4px;}.chip.closable {padding-right: 20px;position: relative;}.chip.closable.closable-wide {align-items: center;display: inline-flex;padding-right: 8px;}.chip.closable.closable-wide > .close {position: relative;right: auto;}.chip.closable.closable-wide > .close::after {align-items: center;border-radius: 3px;display: inline-flex;justify-content: center;margin-left: 8px;opacity: 1;-ms-filter: none;filter: none;height: 16px;width: 16px;}.chip.closable.closable-wide > .close:hover::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide > .close:focus::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide.chip-lg {padding-right: 8px;}.chip.closable.closable-wide.chip-lg > .close::after {margin-left: 8px;height: 20px;width: 20px;}.chip.closable.closable-wide.chip-sm {padding-right: 4px;}.chip.closable.closable-wide.chip-sm > .close::after {margin-left: 4px;height: 12px;width: 12px;}.chip.closable > .close {color: inherit;position: absolute;right: 8px;text-decoration: none;}.chip.closable > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 0;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip.closable > .close:hover {color: inherit;}.chip.closable > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip.closable > .close:active {color: inherit;}.chip.closable > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip.closable.chip-lg {padding-right: 22px;}.chip.closable.chip-lg > .close::after {font-size: 13px;}.chip.closable.chip-sm {padding-right: 19px;}.chip.closable.chip-sm > .close::after {font-size: 9px;}.display-on-hover .displayed-on-hover {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.display-on-hover:hover .displayed-on-hover {opacity: 1;-ms-filter: none;filter: none;-webkit-transition: opacity 200ms ease-in-out;-moz-transition: opacity 200ms ease-in-out;-o-transition: opacity 200ms ease-in-out;-ms-transition: opacity 200ms ease-in-out;transition: opacity 200ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-fast {-webkit-transition: opacity 100ms ease-in-out;-moz-transition: opacity 100ms ease-in-out;-o-transition: opacity 100ms ease-in-out;-ms-transition: opacity 100ms ease-in-out;transition: opacity 100ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-slow {-webkit-transition: opacity 500ms ease-in-out;-moz-transition: opacity 500ms ease-in-out;-o-transition: opacity 500ms ease-in-out;-ms-transition: opacity 500ms ease-in-out;transition: opacity 500ms ease-in-out;}.text-divider {display: flex;align-items: center;text-align: center;}.text-divider::before,.text-divider::after {content: '';flex: 1;border-bottom: 1px solid #e3e4e6;}.text-divider:not(:empty)::before {margin-right: 8px;}.text-divider:not(:empty)::after {margin-left: 8px;}.marginless-divider {border-bottom: 1px solid #e3e4e6;}.form-group {margin-bottom: 24px;}.form-group label {display: block;font-size: 16px;margin-bottom: 4px;color: #222326;line-height: 24px;}.form-control,.form-control[disabled]:hover,.form-control.disabled:hover,.form-control.form-control-outlined,.theme-inverse .form-control.form-control-outlined,.form-control.form-control-outlined[disabled]:hover,.theme-inverse .form-control.form-control-outlined[disabled]:hover,.form-control.form-control-outlined.disabled:hover,.theme-inverse .form-control.form-control-outlined.disabled:hover {background-color: #fff;border-color: #e3e4e6;color: #222326;}.form-control::placeholder,.form-control[disabled]:hover::placeholder,.form-control.disabled:hover::placeholder,.form-control.form-control-outlined::placeholder,.theme-inverse .form-control.form-control-outlined::placeholder,.form-control.form-control-outlined[disabled]:hover::placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover::placeholder,.form-control.form-control-outlined.disabled:hover::placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover::placeholder,.form-control .form-control-placeholder,.form-control[disabled]:hover .form-control-placeholder,.form-control.disabled:hover .form-control-placeholder,.form-control.form-control-outlined .form-control-placeholder,.theme-inverse .form-control.form-control-outlined .form-control-placeholder,.form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.form-control.form-control-outlined.disabled:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover .form-control-placeholder {color: #555659;}.form-control:hover,.form-control.hover,.form-control.form-control-transparent:hover,.form-control.form-control-transparent.hover,.form-control.form-control-outlined:hover,.theme-inverse .form-control.form-control-outlined:hover,.form-control.form-control-outlined.hover,.theme-inverse .form-control.form-control-outlined.hover {background-color: #fff;border-color: #b1b1b3;color: #222326;}.theme-inverse .form-control,.theme-inverse .form-control[disabled]:hover,.theme-inverse .form-control.disabled:hover {background-color: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);color: #d7d7d9;}.theme-inverse .form-control::placeholder,.theme-inverse .form-control[disabled]:hover::placeholder,.theme-inverse .form-control.disabled:hover::placeholder,.theme-inverse .form-control .form-control-placeholder,.theme-inverse .form-control[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.disabled:hover .form-control-placeholder {color: #b1b1b3;}.theme-inverse .form-control:hover,.theme-inverse .form-control.hover {background-color: rgba(215,215,217,0.4);border-color: rgba(215,215,217,0);color: #d7d7d9;}.form-control.invalid,.form-control.invalid[disabled]:hover,.form-control.invalid.disabled:hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.invalid::placeholder,.form-control.invalid[disabled]:hover::placeholder,.form-control.invalid.disabled:hover::placeholder,.form-control.invalid .form-control-placeholder,.form-control.invalid[disabled]:hover .form-control-placeholder,.form-control.invalid.disabled:hover .form-control-placeholder {color: #555659;}.form-control.invalid:hover,.form-control.invalid.hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid,.theme-inverse .form-control.invalid[disabled]:hover,.theme-inverse .form-control.invalid.disabled:hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid::placeholder,.theme-inverse .form-control.invalid[disabled]:hover::placeholder,.theme-inverse .form-control.invalid.disabled:hover::placeholder,.theme-inverse .form-control.invalid .form-control-placeholder,.theme-inverse .form-control.invalid[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.invalid.disabled:hover .form-control-placeholder {color: #f99;}.theme-inverse .form-control.invalid:hover,.theme-inverse .form-control.invalid.hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.form-control-transparent,.form-control.form-control-transparent[disabled]:hover,.form-control.form-control-transparent.disabled:hover {background-color: transparent;border-color: transparent;color: inherit;}.form-control:focus,.form-control.focus,.form-control.form-control-transparent:focus,.form-control.form-control-transparent.focus,.theme-inverse .form-control:focus,.theme-inverse .form-control.focus,.form-control.form-control-outlined:focus,.theme-inverse .form-control.form-control-outlined:focus,.form-control.form-control-outlined.focus,.theme-inverse .form-control.form-control-outlined.focus,.form-control.invalid:focus,.form-control.invalid.focus,.theme-inverse .form-control.invalid:focus,.theme-inverse .form-control.invalid.focus {background-color: #fff;border-color: #0c92f3;color: #222326;}.form-control:focus::placeholder,.form-control.focus::placeholder,.form-control.form-control-transparent:focus::placeholder,.form-control.form-control-transparent.focus::placeholder,.theme-inverse .form-control:focus::placeholder,.theme-inverse .form-control.focus::placeholder,.form-control.form-control-outlined:focus::placeholder,.theme-inverse .form-control.form-control-outlined:focus::placeholder,.form-control.form-control-outlined.focus::placeholder,.theme-inverse .form-control.form-control-outlined.focus::placeholder,.form-control.invalid:focus::placeholder,.form-control.invalid.focus::placeholder,.theme-inverse .form-control.invalid:focus::placeholder,.theme-inverse .form-control.invalid.focus::placeholder,.form-control:focus .form-control-placeholder,.form-control.focus .form-control-placeholder,.form-control.form-control-transparent:focus .form-control-placeholder,.form-control.form-control-transparent.focus .form-control-placeholder,.theme-inverse .form-control:focus .form-control-placeholder,.theme-inverse .form-control.focus .form-control-placeholder,.form-control.form-control-outlined:focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined:focus .form-control-placeholder,.form-control.form-control-outlined.focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.focus .form-control-placeholder,.form-control.invalid:focus .form-control-placeholder,.form-control.invalid.focus .form-control-placeholder,.theme-inverse .form-control.invalid:focus .form-control-placeholder,.theme-inverse .form-control.invalid.focus .form-control-placeholder {color: #555659;}.form-control-label,label.form-control-label {display: block;line-height: 24px;font-size: 16px;margin-bottom: 4px;color: #222326;}.form-control-helper-text {display: block;margin-bottom: 4px;color: #222326;font-size: 14px;line-height: 21px;}.theme-inverse .form-group label,.theme-inverse .form-control-label,.theme-inverse label.form-control-label,.theme-inverse .form-control-helper-text {color: #d7d7d9;}.form-control {border-radius: 3px;border-style: solid;border-width: 1px;display: block;font-size: 16px;line-height: 24px;padding: 7px 15px;resize: vertical;-webkit-transition: border-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out;width: 100%;}.form-control:focus,.form-control.focus {outline: 0;}.form-control[disabled],.form-control.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-control.multi-select-input {padding: 6px 15px;}input.form-control {height: 40px;}.form-control-inline {display: inline-block;width: auto;}.form-control-inherit {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;color: inherit;font-size: inherit;font-weight: inherit;line-height: inherit;margin: -1px -8px;padding: 0 7px;}.form-control-inherit,input.form-control-inherit {height: auto;}.form-control-inherit.form-control-inline {margin-left: 0;margin-right: 0;}.form-control-lg {border-radius: 3px;font-size: 32px;line-height: 40px;padding: 3px 15px;}input.form-control-lg {height: 48px;}.form-control-sm {border-radius: 3px;font-size: 14px;line-height: 21px;padding: 4.5px 15px;}.form-control-sm.multi-select-input {padding: 3.5px 15px;}input.form-control-sm {height: 32px;}.form-check {display: block;}.form-check + .form-check {margin-top: 8px;}.form-check.disabled,.form-check [disabled] {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-check-label {display: inline-block;min-height: 24px;padding-left: 24px;position: relative;vertical-align: top;}.form-check-label .form-text {margin-top: 0;}.form-group label.form-check-label {display: inline-block;margin-bottom: 0;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {-moz-appearance: none;-webkit-appearance: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;border-style: solid;border-width: 1px;display: inline-block;height: 16px;margin: 0;position: relative;vertical-align: -0.15em;width: 16px;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);}.form-check-input:hover,input[type=checkbox].form-check-input:hover,input[type=radio].form-check-input:hover,.form-check.hover .form-check-input,.form-check.hover input[type=checkbox].form-check-input,.form-check.hover input[type=radio].form-check-input {background: rgba(150,151,153,0.4);border-color: #b1b1b3;}.form-check-input:active,input[type=checkbox].form-check-input:active,input[type=radio].form-check-input:active,.form-check.active .form-check-input,.form-check.active input[type=checkbox].form-check-input,.form-check.active input[type=radio].form-check-input {background: rgba(112,113,115,0.4);border-color: #969799;}.form-check-input:checked,input[type=checkbox].form-check-input:checked,input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input:checked:hover,input[type=checkbox].form-check-input:checked:hover,input[type=radio].form-check-input:checked:hover,.form-check.hover .form-check-input:checked,.form-check.hover input[type=checkbox].form-check-input:checked,.form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.form-check-input:checked:active,input[type=checkbox].form-check-input:checked:active,input[type=radio].form-check-input:checked:active,.form-check.active .form-check-input:checked,.form-check.active input[type=checkbox].form-check-input:checked,.form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.form-check-input[disabled]:hover,input[type=checkbox].form-check-input[disabled]:hover,input[type=radio].form-check-input[disabled]:hover,.form-check-input:indeterminate:hover,input[type=checkbox].form-check-input:indeterminate:hover,input[type=radio].form-check-input:indeterminate:hover,.form-check.disabled .form-check-input:hover,.form-check.disabled input[type=checkbox].form-check-input:hover,.form-check.disabled input[type=radio].form-check-input:hover,.form-check-input[disabled]:active,input[type=checkbox].form-check-input[disabled]:active,input[type=radio].form-check-input[disabled]:active,.form-check-input:indeterminate:active,input[type=checkbox].form-check-input:indeterminate:active,input[type=radio].form-check-input:indeterminate:active,.form-check.disabled .form-check-input:active,.form-check.disabled input[type=checkbox].form-check-input:active,.form-check.disabled input[type=radio].form-check-input:active {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);cursor: default;}.form-check-input[disabled]:checked,input[type=checkbox].form-check-input[disabled]:checked,input[type=radio].form-check-input[disabled]:checked,.form-check-input:indeterminate:checked,input[type=checkbox].form-check-input:indeterminate:checked,input[type=radio].form-check-input:indeterminate:checked,.form-check.disabled .form-check-input:checked,.form-check.disabled input[type=checkbox].form-check-input:checked,.form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-label .form-check-input,.form-check-label input[type=checkbox].form-check-input,.form-check-label input[type=radio].form-check-input {left: 0;position: absolute;top: 3px;}.form-check-input:focus,input[type=checkbox].form-check-input:focus,input[type=radio].form-check-input:focus {outline: 0;}.theme-inverse .form-check-input,.theme-inverse input[type=checkbox].form-check-input,.theme-inverse input[type=radio].form-check-input {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;}.theme-inverse .form-check-input:hover,.theme-inverse input[type=checkbox].form-check-input:hover,.theme-inverse input[type=radio].form-check-input:hover,.theme-inverse .form-check.hover .form-check-input,.theme-inverse .form-check.hover input[type=checkbox].form-check-input,.theme-inverse .form-check.hover input[type=radio].form-check-input {background: $formCheckOutlinedHoverBackgroundInverse;border-color: $formCheckOutlinedHoverBorderColorInverse;}.theme-inverse .form-check-input:active,.theme-inverse input[type=checkbox].form-check-input:active,.theme-inverse input[type=radio].form-check-input:active,.theme-inverse .form-check.active .form-check-input,.theme-inverse .form-check.active input[type=checkbox].form-check-input,.theme-inverse .form-check.active input[type=radio].form-check-input {background: $formCheckOutlinedActiveBackgroundInverse;border-color: $formCheckOutlinedActiveBorderColorInverse;}.theme-inverse .form-check-input:checked,.theme-inverse input[type=checkbox].form-check-input:checked,.theme-inverse input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.theme-inverse .form-check-input:checked:hover,.theme-inverse input[type=checkbox].form-check-input:checked:hover,.theme-inverse input[type=radio].form-check-input:checked:hover,.theme-inverse .form-check.hover .form-check-input:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.theme-inverse .form-check-input:checked:active,.theme-inverse input[type=checkbox].form-check-input:checked:active,.theme-inverse input[type=radio].form-check-input:checked:active,.theme-inverse .form-check.active .form-check-input:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.theme-inverse .form-check-input[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input[disabled]:hover,.theme-inverse input[type=radio].form-check-input[disabled]:hover,.theme-inverse .form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input:hover,.theme-inverse .form-check-input[disabled]:active,.theme-inverse input[type=checkbox].form-check-input[disabled]:active,.theme-inverse input[type=radio].form-check-input[disabled]:active,.theme-inverse .form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input:active {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;cursor: default;}.theme-inverse .form-check-input[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input[disabled]:checked,.theme-inverse input[type=radio].form-check-input[disabled]:checked,.theme-inverse .form-check-input:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input:indeterminate:checked,.theme-inverse input[type=radio].form-check-input:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined,input[type=checkbox].form-check-input.form-check-input-outlined,input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #e3e4e6;}.form-check-input.form-check-input-outlined:hover,input[type=checkbox].form-check-input.form-check-input-outlined:hover,input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check.hover .form-check-input.form-check-input-outlined,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #b1b1b3;}.form-check-input.form-check-input-outlined:active,input[type=checkbox].form-check-input.form-check-input-outlined:active,input[type=radio].form-check-input.form-check-input-outlined:active,.form-check.active .form-check-input.form-check-input-outlined,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.active input[type=radio].form-check-input.form-check-input-outlined {background: #f0f1f2;border-color: #969799;}.form-check-input.form-check-input-outlined:checked,input[type=checkbox].form-check-input.form-check-input-outlined:checked,input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined:checked:hover,input[type=checkbox].form-check-input.form-check-input-outlined:checked:hover,input[type=radio].form-check-input.form-check-input-outlined:checked:hover,.form-check.hover .form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined:checked {background: #007fd9;}.form-check-input.form-check-input-outlined:checked:active,input[type=checkbox].form-check-input.form-check-input-outlined:checked:active,input[type=radio].form-check-input.form-check-input-outlined:checked:active,.form-check.active .form-check-input.form-check-input-outlined:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.active input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0068b3;}.form-check-input.form-check-input-outlined[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:hover,input[type=radio].form-check-input.form-check-input-outlined[disabled]:hover,.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check-input.form-check-input-outlined[disabled]:active,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:active,input[type=radio].form-check-input.form-check-input-outlined[disabled]:active,.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:active {background: #fff;border-color: #e3e4e6;cursor: default;}.form-check-input.form-check-input-outlined[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:checked,input[type=radio].form-check-input.form-check-input-outlined[disabled]:checked,.form-check-input.form-check-input-outlined:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:checked,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.4945L7.97802 2.21978L4.85714 3.27472V0H3.53846V3.27472L0.417582 2.21978L0 3.4945L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.4945Z' fill='%23B1B1B3'/%3E%3C/svg%3E%0A");padding: 3px;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:hover,input[type=checkbox].form-check-input.form-check-input-required:hover,input[type=radio].form-check-input.form-check-input-required:hover,.form-check.hover .form-check-input.form-check-input-required,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required,.form-check.hover input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:active,input[type=checkbox].form-check-input.form-check-input-required:active,input[type=radio].form-check-input.form-check-input-required:active,.form-check.active .form-check-input.form-check-input-required,.form-check.active input[type=checkbox].form-check-input.form-check-input-required,.form-check.active input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked:hover,input[type=checkbox].form-check-input.form-check-input-required:checked:hover,input[type=radio].form-check-input.form-check-input-required:checked:hover,.form-check.hover .form-check-input.form-check-input-required:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-required:checked {background: #d94141;}.form-check-input.form-check-input-required:checked:active,input[type=checkbox].form-check-input.form-check-input-required:checked:active,input[type=radio].form-check-input.form-check-input-required:checked:active,.form-check.active .form-check-input.form-check-input-required:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.active input[type=radio].form-check-input.form-check-input-required:checked {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #f26161;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #d94141;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #bf3939;}.form-check-input.form-check-input-required[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-required[disabled]:hover,input[type=radio].form-check-input.form-check-input-required[disabled]:hover,.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-required:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:hover,.form-check-input.form-check-input-required[disabled]:active,input[type=checkbox].form-check-input.form-check-input-required[disabled]:active,input[type=radio].form-check-input.form-check-input-required[disabled]:active,.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-required:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:active {background: ;border-color: ;cursor: default;}.form-check-input.form-check-input-required[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-required[disabled]:checked,input[type=radio].form-check-input.form-check-input-required[disabled]:checked,.form-check-input.form-check-input-required:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:checked,input[type=radio].form-check-input.form-check-input-required:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-required:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.49451L7.97802 2.21978L4.85714 3.27473V0H3.53846V3.27473L0.417582 2.21978L0 3.49451L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.49451Z' fill='white'/%3E%3C/svg%3E%0A");}.form-check-input.invalid,input[type=checkbox].form-check-input.invalid,input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.form-check-input.invalid:hover,input[type=checkbox].form-check-input.invalid:hover,input[type=radio].form-check-input.invalid:hover,.form-check.hover .form-check-input.invalid,.form-check.hover input[type=checkbox].form-check-input.invalid,.form-check.hover input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.form-check-input.invalid:active,input[type=checkbox].form-check-input.invalid:active,input[type=radio].form-check-input.invalid:active,.form-check.active .form-check-input.invalid,.form-check.active input[type=checkbox].form-check-input.invalid,.form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.form-check-input.invalid:checked,input[type=checkbox].form-check-input.invalid:checked,input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.form-check-input.invalid:checked:hover,input[type=checkbox].form-check-input.invalid:checked:hover,input[type=radio].form-check-input.invalid:checked:hover,.form-check.hover .form-check-input.invalid:checked,.form-check.hover input[type=checkbox].form-check-input.invalid:checked,.form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.form-check-input.invalid:checked:active,input[type=checkbox].form-check-input.invalid:checked:active,input[type=radio].form-check-input.invalid:checked:active,.form-check.active .form-check-input.invalid:checked,.form-check.active input[type=checkbox].form-check-input.invalid:checked,.form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.form-check-input.invalid[disabled]:hover,input[type=checkbox].form-check-input.invalid[disabled]:hover,input[type=radio].form-check-input.invalid[disabled]:hover,.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.disabled .form-check-input.invalid:hover,.form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.form-check.disabled input[type=radio].form-check-input.invalid:hover,.form-check-input.invalid[disabled]:active,input[type=checkbox].form-check-input.invalid[disabled]:active,input[type=radio].form-check-input.invalid[disabled]:active,.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=radio].form-check-input.invalid:indeterminate:active,.form-check.disabled .form-check-input.invalid:active,.form-check.disabled input[type=checkbox].form-check-input.invalid:active,.form-check.disabled input[type=radio].form-check-input.invalid:active {background: #fff7f7;border-color: #d94141;cursor: default;}.form-check-input.invalid[disabled]:checked,input[type=checkbox].form-check-input.invalid[disabled]:checked,input[type=radio].form-check-input.invalid[disabled]:checked,.form-check-input.invalid:indeterminate:checked,input[type=checkbox].form-check-input.invalid:indeterminate:checked,input[type=radio].form-check-input.invalid:indeterminate:checked,.form-check.disabled .form-check-input.invalid:checked,.form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid,.theme-inverse input[type=checkbox].form-check-input.invalid,.theme-inverse input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.theme-inverse .form-check-input.invalid:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:hover,.theme-inverse input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check.hover .form-check-input.invalid,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.theme-inverse .form-check-input.invalid:active,.theme-inverse input[type=checkbox].form-check-input.invalid:active,.theme-inverse input[type=radio].form-check-input.invalid:active,.theme-inverse .form-check.active .form-check-input.invalid,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.theme-inverse .form-check-input.invalid:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:checked,.theme-inverse input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid:checked:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:hover,.theme-inverse input[type=radio].form-check-input.invalid:checked:hover,.theme-inverse .form-check.hover .form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.theme-inverse .form-check-input.invalid:checked:active,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:active,.theme-inverse input[type=radio].form-check-input.invalid:checked:active,.theme-inverse .form-check.active .form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.theme-inverse .form-check-input.invalid[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:hover,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:hover,.theme-inverse .form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check-input.invalid[disabled]:active,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:active,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:active,.theme-inverse .form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:active {background: #ffe6e6;border-color: #d94141;cursor: default;}.theme-inverse .form-check-input.invalid[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:checked,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:checked,.theme-inverse .form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}input[type=radio].form-check-input {border-radius: 8px;}input[type=radio].form-check-input:checked::after {background-color: #fff;border-radius: 3px;content: "";height: 6px;left: 5px;position: absolute;top: 5px;width: 6px;}input[type=checkbox].form-check-input {border-radius: 3px;}input[type=checkbox].form-check-input:indeterminate::after {border-bottom: 2px solid #fff;content: "";height: 4px;left: 26%;position: absolute;top: 20%;width: 7px;}input[type=checkbox].form-check-input:checked::after {border-bottom: 2px solid #fff;border-left: 2px solid #fff;content: "";height: 4px;left: 22%;position: absolute;top: 20%;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);width: 7px;}.form-check-inline {display: inline-block;}.form-check-inline + .form-check-inline {margin-left: 24px;margin-top: 0;}.col-form-label {font-size: 16px;line-height: 24px;margin-bottom: 0;padding-top: 8px;}.col-form-label-lg {font-size: 32px;line-height: 40px;padding-top: 4px;}.col-form-label-sm {font-size: 14px;line-height: 21px;padding-top: 5.5px;}.form-text {color: #555659;display: block;font-size: 14px;line-height: 21px;margin-top: 8px;}.form-text.invalid {color: #d94141;}.theme-inverse .form-text {color: #b1b1b3;}.theme-inverse .form-text.invalid {color: #f99;}.form-required::after {color: #d94141;content: "*";font-weight: normal;margin-left: 0.2em;}.chip.default-multi-select-input,.chip.small-multi-select-input {float: left;}.chip.default-multi-select-input {margin: 0.5px 4px 2px;}.chip.small-multi-select-input {margin: -1px 4px 1px;}.form-input-overlay {position: relative;}.form-input-overlay .overlay-front {left: 16px;position: absolute;top: 8px;}.form-input-overlay .overlay-front.overlay-sm {top: 4px;}.form-input-overlay .overlay-front.overlay-lg {top: 12px;}.form-input-overlay .overlay-back {position: absolute;right: 16px;top: 8px;}.form-input-overlay .overlay-back.overlay-sm {top: 4px;}.form-input-overlay .overlay-back.overlay-lg {top: 12px;}.form-input-overlay .form-control ~ .overlay-front,.form-input-overlay .form-control ~ .overlay-back {background-color: transparent;color: #222326;font-size: 16px;}.form-input-overlay .form-control:hover ~ .overlay-front,.form-input-overlay .form-control.hover ~ .overlay-front,.form-input-overlay .form-control:hover ~ .overlay-back,.form-input-overlay .form-control.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control:focus ~ .overlay-front,.form-input-overlay .form-control.focus ~ .overlay-front,.form-input-overlay .form-control:focus ~ .overlay-back,.form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control[disabled] ~ .overlay-front,.form-input-overlay .form-control.disabled ~ .overlay-front,.form-input-overlay .form-control[disabled] ~ .overlay-back,.form-input-overlay .form-control.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-input-overlay .form-control.form-control-transparent ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-inherit ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit ~ .overlay-back {color: inherit;font-size: inherit;font-weight: inherit;}.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .form-input-overlay .form-control ~ .overlay-front,.theme-inverse .form-input-overlay .form-control ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-back {color: #d7d7d9;}.form-input-overlay .form-control.form-control-outlined ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid ~ .overlay-front,.form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.hover ~ .overlay-front,.form-input-overlay .form-control.invalid:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:focus ~ .overlay-front,.form-input-overlay .form-control.invalid.focus ~ .overlay-front,.form-input-overlay .form-control.invalid:focus ~ .overlay-back,.form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .overlay-input-left-sm {padding-left: 32px;}.form-input-overlay .overlay-input-right-sm {padding-right: 32px;}.form-input-overlay .overlay-input-both-sm {padding-left: 32px;padding-right: 32px;}.form-input-overlay .overlay-input-left-md {padding-left: 56px;}.form-input-overlay .overlay-input-right-md {padding-right: 56px;}.form-input-overlay .overlay-input-both-md {padding-left: 56px;padding-right: 56px;}.form-input-overlay .overlay-input-left-lg {padding-left: 80px;}.form-input-overlay .overlay-input-right-lg {padding-right: 80px;}.form-input-overlay .overlay-input-both-lg {padding-left: 80px;padding-right: 80px;}.form-input-overlay .overlay-input-left-icon {padding-left: 40px;}.form-input-overlay .overlay-input-right-icon {padding-right: 40px;}.form-input-overlay .overlay-input-both-icon {padding-left: 40px;padding-right: 40px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl,.col,.col-auto,.col-grow,.col-1,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-10,.col-11,.col-12,.col-sm,.col-sm-auto,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-md,.col-md-auto,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-lg,.col-lg-auto,.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-xl,.col-xl-auto,.col-xl-1,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9,.col-xl-10,.col-xl-11,.col-xl-12 {min-height: 1px;padding-left: 8px;padding-right: 8px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl {margin-left: auto;margin-right: auto;width: 100%;}.container {max-width: 100%;}.container-sm {max-width: 100%;}.container-md {max-width: 100%;}.container-lg {max-width: 100%;}.container-xl {max-width: 100%;}.row {display: flex;flex-wrap: wrap;margin-left: -8px;margin-right: -8px;}.row.no-gutters {margin-left: 0;margin-right: 0;}.row.no-gutters > .col,.row.no-gutters > [class*="col-"] {padding-left: 0;padding-right: 0;}a.row {text-decoration: none;}.col {flex: 1 1 0%;min-width: 0;width: 100%;}.col-auto {flex: 0 0 auto;width: auto;}.col-grow {flex: 1 0 auto;}.col-icon {align-items: center;display: flex;flex: 0 0 24px;}.col-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-3 {flex: 0 0 25%;max-width: 25%;}.col-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-6 {flex: 0 0 50%;max-width: 50%;}.col-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-9 {flex: 0 0 75%;max-width: 75%;}.col-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-12 {flex: 0 0 100%;max-width: 100%;}.mo-identicon {background-color: #e3e4e6;border-radius: 3px;color: #555659;display: inline-block;font-size: 12px;height: 24px;line-height: 24px;overflow: hidden;position: relative;text-align: center;text-decoration: none;vertical-align: middle;width: 24px;}.mo-identicon img {height: 100%;width: 100%;}.mo-identicon-initials {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;color: #fff;height: 100%;text-shadow: 0 0 2px rgba(0,0,0,0.2);width: 100%;}.mo-identicon-placeholder {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;}.mo-identicon-placeholder .icon {color: #e3e4e6;height: 18px;width: 18px;}.mo-identicon-placeholder .icon,.momentum-body .mo-identicon-placeholder .icon {vertical-align: middle;}.mo-identicon-sm {font-size: 10px;height: 16px;line-height: 16px;width: 16px;}.mo-identicon-sm .mo-identicon-placeholder .icon {height: 12px;width: 12px;}.mo-identicon-lg {font-size: 14px;height: 32px;line-height: 32px;width: 32px;}.mo-identicon-lg .mo-identicon-placeholder .icon {height: 24px;width: 24px;}.mo-identicon-xl {font-size: 16px;height: 40px;line-height: 40px;width: 40px;}.mo-identicon-xl .mo-identicon-placeholder .icon {height: 30px;width: 30px;}.mo-identicon-initials-0 {background: -webkit-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -moz-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -o-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -ms-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: linear-gradient(-15deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;}.mo-identicon-initials-1 {background: -webkit-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -moz-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -o-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -ms-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: linear-gradient(-15deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;}.mo-identicon-initials-2 {background: -webkit-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -moz-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -o-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -ms-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: linear-gradient(-15deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;}.mo-identicon-initials-3 {background: -webkit-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -moz-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -o-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -ms-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: linear-gradient(-15deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;}.mo-identicon-initials-4 {background: -webkit-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -moz-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -o-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -ms-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: linear-gradient(-15deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;}.mo-identicon-initials-5 {background: -webkit-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -moz-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -o-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -ms-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: linear-gradient(-15deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;}.mo-identicon-initials-6 {background: -webkit-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -moz-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -o-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -ms-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: linear-gradient(-15deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;}.mo-identicon-initials-7 {background: -webkit-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -moz-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -o-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -ms-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: linear-gradient(-15deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;}.mo-identicon-initials-8 {background: -webkit-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -moz-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -o-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -ms-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: linear-gradient(-15deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;}.mo-identicon-initials-9 {background: -webkit-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -moz-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -o-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -ms-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: linear-gradient(-15deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;}.mo-identicon-initials-10 {background: -webkit-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -moz-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -o-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -ms-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: linear-gradient(-15deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;}.mo-identicon-initials-11 {background: -webkit-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -moz-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -o-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -ms-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: linear-gradient(-15deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;}.mo-identicon-initials-12 {background: -webkit-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -moz-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -o-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -ms-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: linear-gradient(-15deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;}.mo-identicon-initials-13 {background: -webkit-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -moz-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -o-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -ms-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: linear-gradient(-15deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;}.mo-identicon-initials-14 {background: -webkit-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -moz-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -o-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -ms-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: linear-gradient(-15deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;}.mo-identicon-initials-15 {background: -webkit-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -moz-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -o-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -ms-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: linear-gradient(-15deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;}.mo-identicon-initials-16 {background: -webkit-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -moz-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -o-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -ms-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: linear-gradient(-15deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;}.mo-identicon-initials-17 {background: -webkit-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -moz-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -o-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -ms-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: linear-gradient(-15deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;}.mo-identicon-initials-18 {background: -webkit-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -moz-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -o-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -ms-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: linear-gradient(-15deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;}.mo-identicon-initials-19 {background: -webkit-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -moz-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -o-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -ms-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: linear-gradient(-15deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;}.mo-identicon-initials-20 {background: -webkit-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -moz-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -o-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -ms-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: linear-gradient(-15deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;}.mo-identicon-initials-21 {background: -webkit-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -moz-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -o-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -ms-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: linear-gradient(-15deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;}.mo-identicon-initials-22 {background: -webkit-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -moz-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -o-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -ms-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: linear-gradient(-15deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;}.mo-identicon-initials-23 {background: -webkit-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -moz-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -o-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -ms-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: linear-gradient(-15deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;}.mo-identicon-initials-24 {background: -webkit-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -moz-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -o-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -ms-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: linear-gradient(-15deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;}.mo-identicon-initials-25 {background: -webkit-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -moz-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -o-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -ms-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: linear-gradient(-15deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;}.mo-identicon-initials-26 {background: -webkit-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -moz-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -o-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -ms-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: linear-gradient(-15deg, #515151, #515151 49%, #707070 51%, #707070) #515151;}.mo-identicon-initials-27 {background: -webkit-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -moz-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -o-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -ms-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: linear-gradient(-15deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;}.mo-identicon-initials-28 {background: -webkit-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -moz-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -o-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -ms-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: linear-gradient(-15deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;}.mo-identicon-initials-29 {background: -webkit-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -moz-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -o-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -ms-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: linear-gradient(-15deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;}.mo-identicon-initials-30 {background: -webkit-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -moz-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -o-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -ms-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: linear-gradient(-15deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;}.list-row {border-bottom: 1px solid #e3e4e6;border-top: 1px solid #e3e4e6;display: flex;flex-wrap: wrap;font-size: 16px;line-height: 24px;}.list-row + .list-row {margin-top: -1px;}.list-row > .col,.list-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.list-row.clickable:hover {background: #f0f1f2;cursor: pointer;}.list-row.clickable:active {background: #e3e4e6;}.list-row.clickable.selected {background: #f3faff;}.list-row.clickable.selected:hover {background: #e1f3ff;}.list-row.clickable.selected:active {background: #bfe5ff;}.list-row.hover,.list-row > .col.hover,.list-row > [class*="col-"].hover {background: #f0f1f2;}.list-row.active,.list-row > .col.active,.list-row > [class*="col-"].active {background: #e3e4e6;}.list-row.selected,.list-row > .col.selected,.list-row > [class*="col-"].selected {background: #f3faff;}.list-row.selected.hover,.list-row > .col.selected.hover,.list-row > [class*="col-"].selected.hover {background: #e1f3ff;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"] {text-decoration: none;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"],a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover,a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active,a.list-row:visited,.momentum-body a.list-row:visited,.list-row > a.col:visited,.list-row > a[class*="col-"]:visited,.momentum-body .momentum-body a.list-row:visited,.momentum-body .list-row > a.col:visited,.momentum-body .list-row > a[class*="col-"]:visited {color: #222326;}a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover {background: #f0f1f2;}a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active {background: #e3e4e6;}a.list-row.selected:active,.momentum-body a.list-row.selected:active,.list-row > a.col.selected:active,.list-row > a[class*="col-"].selected:active {background: #bfe5ff;}a.list-row.selected.selected:hover,.momentum-body a.list-row.selected.selected:hover,.list-row > a.col.selected.selected:hover,.list-row > a[class*="col-"].selected.selected:hover {background: #e1f3ff;}.list-row > .col-form-label {padding-top: 16px;}.list-row > .col-form-label-lg {padding-top: 12px;}.list-row > .col-form-label-sm {padding-top: 13.5px;}.list-row-head {border-top: 0;}.col-list-row-header {align-self: flex-end;color: #969799;font-size: 12px;line-height: 18px;}.menu-row {display: flex;flex-wrap: wrap;font-size: 14px;line-height: 21px;padding-left: 8px;padding-right: 8px;}.menu-row h3,.menu-row h4 {margin-bottom: 0;}.menu-row h3,.menu-row .momentum-body h3,.menu-row .text-h3,.menu-row .text-h3_5 {font-size: 20px;line-height: 24px;}.menu-row .font-size-h3 {font-size: 20px;}.menu-row .line-height-h3 {line-height: 24px;}.menu-row h4,.menu-row .momentum-body h4,.menu-row .text-h4 {font-size: 16px;line-height: 24px;}.menu-row .font-size-h4 {font-size: 16px;}.menu-row .line-height-h4 {line-height: 24px;}.menu-row > .col,.menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.menu-row.hover {background: #f0f1f2;}.menu-row.active {background: #e3e4e6;}.menu-row.selected {background: #e1f3ff;}.menu-row.selected.hover {background: #bfe5ff;}.menu-row.selected.active {background: #a6daff;}.menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.menu-row {text-decoration: none;}a.menu-row:hover,a.menu-row:active,a.menu-row:visited {color: inherit;}a.menu-row:hover {background: #f0f1f2;}a.menu-row:active {background: #e3e4e6;}a.menu-row.selected:hover {background: #bfe5ff;}a.menu-row.selected:active {background: #a6daff;}.menu-divider {border-top: 1px solid #e3e4e6;margin-bottom: 4px;margin-top: 3px;}.message {color: #222326;background-color: #f0f1f2;border-radius: 3px;padding-bottom: 8px;padding-left: 40px;padding-right: 32px;padding-top: 8px;position: relative;}.message > .icon {position: absolute;left: 16px;top: 11px;}.message > .icon path {fill: #969799;}.message > p,.momentum-body .message > p {margin-bottom: 0;}.message > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;line-height: 16px;height: 16px;position: absolute;right: 16px;text-align: center;top: 11px;width: 16px;}.message > .close:hover::after {color: #555659;}.message > .close:active::after {color: #222326;}.message > .message-buttons {clear: left;float: right;margin-top: -4px;margin-right: -16px;padding-left: 4px;}.message > .message-buttons > .button-link {margin-top: 4px;}.message.message-info {background-color: #e1f3ff;}.message.message-info > .icon path {fill: #0c92f3;}.message.message-warning {background-color: #fec;}.message.message-warning > .icon path {fill: #ff9000;}.message.message-positive {background-color: #d4f5c4;}.message.message-positive > .icon path {fill: #39bf71;}.message.message-negative {background-color: #ffe6e6;}.message.message-negative > .icon path {fill: #d94141;}.message.message-gray {background-color: #f0f1f2;}.message.message-blue {background-color: #e1f3ff;}.message.message-red {background-color: #ffe6e6;}.message.message-green {background-color: #d4f5c4;}.message.message-yellow {background-color: #fec;}.message.message-rose {background-color: #ffe0f0;}.message.message-violet {background-color: #f5e0ff;}.message.message-turquoise {background-color: #d9f7fa;}.message.message-striped-red {background: -webkit-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -moz-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -o-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -ms-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: repeating-linear-gradient(105deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);}.message.message-striped-blue {background: -webkit-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -moz-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -o-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -ms-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: repeating-linear-gradient(105deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);}.message.message-striped-green {background: -webkit-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -moz-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -o-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -ms-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: repeating-linear-gradient(105deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);}.message.message-inverse {background-color: #555659;color: #fff;}.message.message-inverse > .icon path {fill: #b1b1b3;}.message.message-inverse > .close::after {color: #969799;}.message.message-inverse > .close:hover::after {color: #b1b1b3;}.message.message-inverse > .close:active::after {color: #707173;}.message.message-compact {padding-top: 4px;padding-bottom: 4px;}.message.message-compact > .icon {top: 8.125px;}.message.message-compact > .close::after {top: 8.125px;}.message.message-compact > .message-buttons {margin-top: -5.5px;}.message.message-compact > .message-buttons > .button-link {margin-top: 5.5px;}.modal-backdrop {background-color: rgba(0,0,0,0.3);bottom: 0;display: none;left: 0;position: absolute;right: 0;top: 0;width: 100%;}.modal-backdrop.show {display: flex;}.modal {background: #fff;border-radius: 3px;display: flex;flex-direction: column;left: 0;margin: 0 auto;max-height: calc(100% - 96px);max-width: 640px;min-width: 480px;position: absolute;right: 0;top: 80px;}.modal-content {display: flex;flex-direction: column;height: 100%;overflow: auto;padding: 0 32px;}.modal-content.no-padding {padding: 0;}.modal-actions {align-items: flex-end;display: flex;flex: auto;justify-content: flex-end;padding: 24px 32px;}.modal-actions-distributed {align-items: flex-end;display: flex;flex: auto;justify-content: space-between;padding: 32px 32px;}.modal-navigation {height: auto;padding: 24px 32px 24px 32px;position: relative;}.modal-navigation.no-padding {padding: 0;}.modal-close {color: #555659;position: absolute;right: 16px;top: 16px;}.nav-link,.momentum-body .nav-link {color: $navLinkColor;font-size: $navLinkFontSize;text-decoration: none;}.nav-link:hover,.momentum-body .nav-link:hover {color: $navLinkHoverColor;text-decoration: underline;}.nav-link:active,.momentum-body .nav-link:active {color: $navLinkActiveColor;text-decoration: underline;}.nav-link > .icon {margin-left: 4px;margin-right: 4px;}.nav-link > .icon:first-child {margin-left: 0;}.nav-link > .icon:last-child {margin-right: 0;}.progress-bar .bar,.progress-bar .bar-interactive {align-items: center;border-radius: 3px;display: flex;height: 16px;justify-content: center;-webkit-transition: width 350ms ease-out;-moz-transition: width 350ms ease-out;-o-transition: width 350ms ease-out;-ms-transition: width 350ms ease-out;transition: width 350ms ease-out;}.progress-bar {align-items: center;border-radius: 3px;display: flex;}.progress-bar .bar-container {align-content: center;align-items: center;display: flex;padding: 0;width: 100%;justify-content: space-between;position: relative;}.progress-bar .bar-interactive:hover {cursor: pointer;}.progress-bar .bar-progress-text {display: flex;font-size: 12px;line-height: 12px;position: absolute;padding: 0 0 0 4px;}.progress-bar .bar-progress-text-inverted {position: static;}.progress-bar .bar-title {margin-right: 8px;text-transform: capitalize;}.score {background-color: #555659;border-radius: 3px;color: #fff;display: inline-block;font-size: 16px;height: 24px;line-height: 24px;overflow: hidden;text-align: center;vertical-align: middle;width: 24px;}.score .icon {height: 16px;width: 16px;}.score .mo-identicon {border-radius: 0;vertical-align: unset;}.score.score-worst {background-color: #555659;color: #d7d7d9;}.score.score-bad {background-color: #555659;color: #b1b1b3;}.score.score-good {background-color: #555659;color: #61d086;}.score.score-best {background-color: #555659;color: #8ae58a;}.score.score-unknown {background-color: #e3e4e6;color: #555659;}.score.score-sm {font-size: 12px;height: 16px;line-height: 16px;width: 16px;}.score.score-sm .icon {height: 12px;width: 12px;}.score.score-lg {font-size: 20px;height: 32px;line-height: 32px;width: 32px;}.score.score-lg .icon {height: 20px;width: 20px;}.score.score-xl {font-size: 24px;height: 40px;line-height: 40px;width: 40px;}.score.score-xl .icon {height: 24px;width: 24px;}.score-group {display: inline-block;}.score-group .score {border-radius: 0;}.score-group .score:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.score-group .score:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.arrow {position: relative;}.arrow .line,.arrow .line::after {height: 40px;}.arrow .line {display: block;text-align: center;}.arrow .line::after {position: absolute;background: #b1b1b3;content: ' ';margin-left: -1px;width: 2px;}.arrow .arrow-overlay {position: absolute;top: 50%;left: 50%;-webkit-transform: translate(-50%, -50%);-moz-transform: translate(-50%, -50%);-o-transform: translate(-50%, -50%);-ms-transform: translate(-50%, -50%);transform: translate(-50%, -50%);}.arrow.direction-down .arrow-head,.arrow.direction-up .arrow-head {width: 10px;height: 10px;position: absolute;left: calc(50% - 5px);}.arrow.direction-down .arrow-head::after,.arrow.direction-up .arrow-head::after {display: block;position: absolute;content: '';height: 10px;margin: 0;padding: 0;width: 10px;-webkit-box-shadow: inset -2px 2px 0 0 #b1b1b3;box-shadow: inset -2px 2px 0 0 #b1b1b3;}.arrow.direction-up .arrow-head {top: 0;}.arrow.direction-up .arrow-head::after {-moz-transform: rotate(-45deg);-ms-transform: rotate(-45deg);-o-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.arrow.direction-down .arrow-head {bottom: 0;}.arrow.direction-down .arrow-head::after {-moz-transform: rotate(135deg);-ms-transform: rotate(135deg);-o-transform: rotate(135deg);-webkit-transform: rotate(135deg);-webkit-transform: rotate(135deg);-moz-transform: rotate(135deg);-o-transform: rotate(135deg);-ms-transform: rotate(135deg);transform: rotate(135deg);}.arrow.length-long .line,.arrow.length-long .line::after {height: 72px;}.animation-shimmer {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -moz-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -o-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -ms-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: linear-gradient(to right, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-size: 1000px 100%;}.animation-shimmer-inverse {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -moz-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -o-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -ms-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: linear-gradient(to right, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-size: 1000px 100%;}@-moz-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-webkit-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-o-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}.sidebar-menu {background-color: #f9f9f9;height: 100%;overflow-y: auto;width: 304px;}.sidebar-menu-width {width: 304px;}.sidebar-menu-row {color: #969799;display: flex;flex-wrap: wrap;padding-left: 16px;padding-right: 16px;}.sidebar-menu-row h4,.sidebar-menu-row h3 {margin-bottom: 0;}.sidebar-menu-row > .col,.sidebar-menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.sidebar-menu-row.hover {background: #fff;}.sidebar-menu-row.active {background: #e1f3ff;}.sidebar-menu-row.selected {color: #555659;background: #fff;border-left: 4px solid #0c92f3;padding-left: 12px;}.sidebar-menu-row.selected.hover {background: #f3faff;}.sidebar-menu-row.selected.active {background: #e1f3ff;}.sidebar-menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.sidebar-menu-row {color: #969799;text-decoration: none;}a.sidebar-menu-row:hover,a.sidebar-menu-row:active,a.sidebar-menu-row:visited {color: inherit;}a.sidebar-menu-row:hover {background: #fff;}a.sidebar-menu-row.selected {color: #555659;}a.sidebar-menu-row.selected:hover {background: #f3faff;}a.sidebar-menu-row.selected:active {background: #e1f3ff;}.sidebar-button-menu {width: 64px;height: 100%;overflow-y: auto;background-color: #f9f9f9;display: flex;flex-direction: column;align-items: center;}.sidebar-button-menu .sidebar-button-menu-row {margin-bottom: 8px;}.sidebar-button-menu .sidebar-button-menu-row .button {border: none;background-color: unset;background-image: unset;}.sidebar-button-menu .sidebar-button-menu-row:hover {margin-bottom: 6px;}.sidebar-button-menu .sidebar-button-menu-row:hover .button {-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);border-bottom: 2px solid #0c92f3;}.sidebar-button-menu .sidebar-button-menu-row.selected .button {background-color: #fff;-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);}.tab-links,.tab-links-border-bottom {display: flex;}.tab-link {border-bottom: 4px solid transparent;color: #969799;cursor: pointer;margin-left: 8px;margin-right: 8px;padding-bottom: 8px;}.tab-link:first-child {margin-left: 0;}.tab-link:last-child {margin-right: 0;}.tab-link,.momentum-body a.tab-link {text-decoration: none;color: #969799;}.tab-link:hover,.momentum-body a.tab-link:hover,.tab-link.hover,.momentum-body a.tab-link.hover {color: #707173;border-bottom-color: #b1b1b3;}.tab-link:active,.momentum-body a.tab-link:active {border-bottom-color: #969799;}.tab-link.selected,.momentum-body a.tab-link.selected {border-bottom-color: #0c92f3;color: #555659;}.tab-links-border-bottom {border-bottom: 1px solid #e3e4e6;}.tab-links-border-bottom .tab-link {margin-bottom: -1px;margin-left: 0;margin-right: 0;padding-left: 8px;padding-right: 8px;}.tabs {border-bottom: 1px solid #e3e4e6;display: flex;}.tab {border-color: #e3e4e6;border-style: solid;border-top-left-radius: 3px;border-top-right-radius: 3px;border-width: 1px;cursor: pointer;margin-bottom: -1px;margin-left: 8px;margin-right: 8px;padding: 8px 16px;text-align: center;}.tab:first-child {margin-left: 0;}.tab:last-child {margin-right: 0;}.tab,.momentum-body a.tab {background-color: #fff;color: #969799;text-decoration: none;}.tab:hover,.momentum-body a.tab:hover,.tab.hover,.momentum-body a.tab.hover {color: #707173;}.tab.selected,.momentum-body a.tab.selected {border-bottom-color: #fff;color: #555659;}.toast {-webkit-animation: toastFadeIn 0.3s ease-out;-moz-animation: toastFadeIn 0.3s ease-out;-o-animation: toastFadeIn 0.3s ease-out;-ms-animation: toastFadeIn 0.3s ease-out;animation: toastFadeIn 0.3s ease-out;border-left: 4px solid #969799;border-radius: 3px;display: inline-block;max-width: 480px;padding-bottom: 8px;padding-left: 48px;padding-right: 48px;padding-top: 8px;position: relative;}.toast > .icon {color: #555659;left: 16px;position: absolute;top: 12px;}.toast > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;height: 16px;line-height: 16px;position: absolute;right: 16px;text-align: center;top: 12px;width: 16px;}.toast > .close:hover::after {color: #555659;}.toast > .close:active::after {color: #222326;}.toast > .toast-buttons {margin-bottom: 8px;margin-top: 16px;}.toast.toast-info {border-left-color: #0c92f3;}.toast.toast-warning {border-left-color: #ffa60d;}.toast.toast-positive {border-left-color: #39bf71;}.toast.toast-negative {border-left-color: #d94141;}.toast.theme-inverse > .icon {color: #969799;}.toast.theme-inverse > .close::after {color: #969799;}.toast.theme-inverse > .close:hover::after {color: #b1b1b3;}.toast.theme-inverse > .close:active::after {color: #707173;}@-moz-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-webkit-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-o-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}.toggle {color: rgba(85,86,89,0.7);background-color: rgba(177,177,179,0.4);border-radius: 11px;border-width: 0;cursor: pointer;display: inline-block;height: 22px;margin: 1px 8px;padding: 0;position: relative;-webkit-transition: background-color 0.15s ease-in;-moz-transition: background-color 0.15s ease-in;-o-transition: background-color 0.15s ease-in;-ms-transition: background-color 0.15s ease-in;transition: background-color 0.15s ease-in;vertical-align: top;width: 40px;}.toggle:hover,.toggle.hover {background-color: rgba(177,177,179,0.6);}.toggle:active,.toggle.active {background-color: #b1b1b3;}.toggle:focus,.toggle.focus {outline: none;}.toggle[disabled],.toggle.disabled {background-color: rgba(177,177,179,0.4);}.toggle:first-child {margin-left: 0;}.toggle:last-child {margin-right: 0;}.toggle::after {background-color: #fff;border-radius: 8px;content: " ";display: block;height: 16px;left: 3px;top: 3px;position: absolute;-webkit-transition: left 0.15s linear;-moz-transition: left 0.15s linear;-o-transition: left 0.15s linear;-ms-transition: left 0.15s linear;transition: left 0.15s linear;width: 16px;}.toggle .icon,.momentum-body .toggle .icon {position: absolute;height: 12px;width: 12px;left: 23px;top: 5px;}.toggle.selected {color: rgba(255,255,255,0.7);background-color: #0c92f3;}.toggle.selected:hover,.toggle.selected.hover {background-color: #007fd9;}.toggle.selected:active,.toggle.selected.active {background-color: #0068b3;}.toggle.selected:focus,.toggle.selected.focus {outline: none;}.toggle.selected[disabled],.toggle.selected.disabled {background-color: #0c92f3;}.toggle.selected::after {left: 21px;}.toggle.selected .icon,.momentum-body .toggle.selected .icon {left: 5px;}.toggle.disabled {cursor: default;pointer-events: none;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.toggle.toggle-yellow.selected {color: rgba(255,255,255,0.7);background-color: #fb3;}.toggle.toggle-yellow.selected:hover,.toggle.toggle-yellow.selected.hover {background-color: #ffa60d;}.toggle.toggle-yellow.selected:active,.toggle.toggle-yellow.selected.active {background-color: #ff9000;}.toggle.toggle-yellow.selected:focus,.toggle.toggle-yellow.selected.focus {outline: none;}.toggle.toggle-yellow.selected[disabled],.toggle.toggle-yellow.selected.disabled {background-color: #fb3;}.toggle-lg {border-radius: 14px;height: 28px;width: 48px;margin-top: 4px;margin-bottom: 4px;}.toggle-lg::after {border-radius: 10px;height: 20px;left: 4px;top: 4px;width: 20px;}.toggle-lg .icon,.momentum-body .toggle-lg .icon {height: 16px;width: 16px;left: 26px;top: 6px;}.toggle-lg.selected::after {left: 24px;}.toggle-lg.selected .icon,.momentum-body .toggle-lg.selected .icon {left: 6px;}.toggle-sm {border-radius: 8px;height: 16px;width: 32px;margin-top: 2.5px;margin-bottom: 2.5px;}.toggle-sm::after {border-radius: 6px;height: 12px;left: 2px;top: 2px;width: 12px;}.toggle-sm .icon,.momentum-body .toggle-sm .icon {height: 9px;width: 9px;left: 19.5px;top: 3.5px;}.toggle-sm.selected::after {left: 18px;}.toggle-sm.selected .icon,.momentum-body .toggle-sm.selected .icon {left: 3.5px;}.text-h1 {font-size: 40px;font-weight: bold;line-height: 48px;}.text-h2 {font-size: 32px;font-weight: bold;line-height: 40px;}.text-h3 {font-size: 24px;font-weight: bold;line-height: 36px;}.text-h3_5 {font-size: 20px;font-weight: bold;line-height: 24px;}.text-h4 {font-size: 16px;font-weight: bold;line-height: 24px;}.text-h5 {font-size: 14px;font-weight: bold;line-height: 21px;}.text-base {font-size: 16px;font-weight: normal;line-height: 24px;}.text-small {font-size: 14px;font-weight: normal;line-height: 21px;}.text-caption {font-size: 12px;font-weight: normal;line-height: 18px;}.font-size-h1 {font-size: 40px;}.font-size-h2 {font-size: 32px;}.font-size-h3 {font-size: 24px;}.font-size-h3_5 {font-size: 20px;}.font-size-h4 {font-size: 16px;}.font-size-base {font-size: 16px;}.font-size-small {font-size: 14px;}.font-size-caption {font-size: 12px;}.line-height-h1 {line-height: 48px;}.line-height-h2 {line-height: 40px;}.line-height-h3 {line-height: 36px;}.line-height-h3_5 {line-height: 24px;}.line-height-h4 {line-height: 24px;}.line-height-base {line-height: 24px;}.line-height-small {line-height: 21px;}.line-height-caption {line-height: 18px;}.text-color-heading {color: #222326;}.text-color-body {color: #222326;}.text-muted {color: #555659;}.text-positive {color: #19a654;}.text-muted-positive {color: #61d086;}.text-negative {color: #d94141;}.text-muted-negative {color: #f99;}.upload {align-items: center;background-color: #fff;border: 2px #d7d7d9;border-style: dashed;color: #969799;cursor: pointer;display: flex;flex-direction: column;justify-content: center;padding: 8px;position: relative;}.upload:hover,.upload.hover {background-color: #f3faff;}.upload .upload-file {cursor: pointer;height: 100%;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);position: absolute;width: 100%;}.upload > .remove::after {align-items: center;background-color: #555659;border-radius: 50%;color: #fff;content: "✕";display: flex;font-size: 12px;height: 18px;justify-content: center;line-height: 12px;position: absolute;right: 12px;top: 12px;width: 18px;}.upload > .remove:hover::after {background-color: #707173;}.upload > .remove:active::after {background-color: #3b3d3f;}.upload-dragging {background-color: #f3faff;}.upload-no-border {border: 0;}.upload-dropping {background-color: #f3faff;border: 2px #0c92f3;border-style: dashed;}.upload-error {border: 2px #d94141;border-style: dashed;}.upload-preview {display: inline-block;line-height: 0;padding: 0;}.upload-icon {color: #d7d7d9;}.upload-icon.icon {margin-left: 0;margin-right: 0;}.animation-rotate-infinite {-webkit-animation: rotate-infinite infinite;-moz-animation: rotate-infinite infinite;-o-animation: rotate-infinite infinite;-ms-animation: rotate-infinite infinite;animation: rotate-infinite infinite;}.animation-fade-in {-webkit-animation: fade-in 1 ease both;-moz-animation: fade-in 1 ease both;-o-animation: fade-in 1 ease both;-ms-animation: fade-in 1 ease both;animation: fade-in 1 ease both;}.animation-fade-out {-webkit-animation: fade-out 1 ease both;-moz-animation: fade-out 1 ease both;-o-animation: fade-out 1 ease both;-ms-animation: fade-out 1 ease both;animation: fade-out 1 ease both;}.animation-ease {-webkit-animation-timing-function: ease;-moz-animation-timing-function: ease;-o-animation-timing-function: ease;-ms-animation-timing-function: ease;animation-timing-function: ease;}.animation-linear {-webkit-animation-timing-function: linear;-moz-animation-timing-function: linear;-o-animation-timing-function: linear;-ms-animation-timing-function: linear;animation-timing-function: linear;}.animation-duration-100ms {-webkit-animation-duration: 100ms;-moz-animation-duration: 100ms;-o-animation-duration: 100ms;-ms-animation-duration: 100ms;animation-duration: 100ms;}.animation-duration-200ms {-webkit-animation-duration: 200ms;-moz-animation-duration: 200ms;-o-animation-duration: 200ms;-ms-animation-duration: 200ms;animation-duration: 200ms;}.animation-duration-300ms {-webkit-animation-duration: 300ms;-moz-animation-duration: 300ms;-o-animation-duration: 300ms;-ms-animation-duration: 300ms;animation-duration: 300ms;}.animation-duration-400ms {-webkit-animation-duration: 400ms;-moz-animation-duration: 400ms;-o-animation-duration: 400ms;-ms-animation-duration: 400ms;animation-duration: 400ms;}.animation-duration-500ms {-webkit-animation-duration: 500ms;-moz-animation-duration: 500ms;-o-animation-duration: 500ms;-ms-animation-duration: 500ms;animation-duration: 500ms;}.animation-duration-1000ms {-webkit-animation-duration: 1000ms;-moz-animation-duration: 1000ms;-o-animation-duration: 1000ms;-ms-animation-duration: 1000ms;animation-duration: 1000ms;}.animation-duration-2000ms {-webkit-animation-duration: 2000ms;-moz-animation-duration: 2000ms;-o-animation-duration: 2000ms;-ms-animation-duration: 2000ms;animation-duration: 2000ms;}.animation-count-1 {-webkit-animation-iteration-count: 1;-moz-animation-iteration-count: 1;-o-animation-iteration-count: 1;-ms-animation-iteration-count: 1;animation-iteration-count: 1;}.animation-count-infinite {-webkit-animation-iteration-count: infinite;-moz-animation-iteration-count: infinite;-o-animation-iteration-count: infinite;-ms-animation-iteration-count: infinite;animation-iteration-count: infinite;}.animation-direction-normal {-webkit-animation-direction: normal;-moz-animation-direction: normal;-o-animation-direction: normal;-ms-animation-direction: normal;animation-direction: normal;}.animation-direction-reverse {-webkit-animation-direction: reverse;-moz-animation-direction: reverse;-o-animation-direction: reverse;-ms-animation-direction: reverse;animation-direction: reverse;}@-moz-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-moz-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}.border {border: 1px solid #e3e4e6;}.border-top {border-top: 1px solid #e3e4e6;}.border-right {border-right: 1px solid #e3e4e6;}.border-bottom {border-bottom: 1px solid #e3e4e6;}.border-left {border-left: 1px solid #e3e4e6;}.border-width-1 {border-width: 4px;}.border-width-2 {border-width: 8px;}.border-width-3 {border-width: 12px;}.border-width-4 {border-width: 16px;}.border-width-5 {border-width: 20px;}.border-width-6 {border-width: 24px;}.border-width-7 {border-width: 28px;}.border-width-8 {border-width: 32px;}.border-width-9 {border-width: 36px;}.border-width-10 {border-width: 40px;}.border-width-11 {border-width: 44px;}.border-width-12 {border-width: 48px;}.border-width-13 {border-width: 52px;}.border-width-14 {border-width: 56px;}.border-width-15 {border-width: 60px;}.border-width-16 {border-width: 64px;}.border-width-17 {border-width: 68px;}.border-width-18 {border-width: 72px;}.border-width-19 {border-width: 76px;}.border-width-20 {border-width: 80px;}.border-width-21 {border-width: 84px;}.border-width-22 {border-width: 88px;}.border-width-23 {border-width: 92px;}.border-width-24 {border-width: 96px;}.border-width-25 {border-width: 100px;}.border-width-26 {border-width: 104px;}.border-width-27 {border-width: 108px;}.border-width-28 {border-width: 112px;}.border-width-29 {border-width: 116px;}.border-width-30 {border-width: 120px;}.border-none {border: 0;}.border-top-none {border-top: 0;}.border-right-none {border-right: 0;}.border-bottom-none {border-bottom: 0;}.border-left-none {border-left: 0;}.rounded {border-radius: 3px;}.circle {border-radius: 50%;}.rounded-top {border-radius: 3px 3px 0 0;}.rounded-right {border-radius: 0 3px 3px 0;}.rounded-bottom {border-radius: 0 0 3px 3px;}.rounded-left {border-radius: 3px 0 0 3px;}.not-rounded {border-radius: 0;}.dashed {border-style: dashed;}.text-white {color: #fff;}.bg-white {background-color: #fff;}.border-white {border-color: #fff;}.text-black {color: #000;}.bg-black {background-color: #000;}.border-black {border-color: #000;}.text-ghost {color: #f4f7fa;}.bg-ghost {background-color: #f4f7fa;}.border-ghost {border-color: #f4f7fa;}.text-gray {color: #969799;}.bg-gray {background-color: #969799;}.border-gray {border-color: #969799;}.text-blue {color: #0c92f3;}.bg-blue {background-color: #0c92f3;}.border-blue {border-color: #0c92f3;}.text-red {color: #d94141;}.bg-red {background-color: #d94141;}.border-red {border-color: #d94141;}.text-green {color: #39bf71;}.bg-green {background-color: #39bf71;}.border-green {border-color: #39bf71;}.text-yellow {color: #ffa60d;}.bg-yellow {background-color: #ffa60d;}.border-yellow {border-color: #ffa60d;}.text-rose {color: #dc4c7d;}.bg-rose {background-color: #dc4c7d;}.border-rose {border-color: #dc4c7d;}.text-violet {color: #a452cc;}.bg-violet {background-color: #a452cc;}.border-violet {border-color: #a452cc;}.text-turquoise {color: #1cadba;}.bg-turquoise {background-color: #1cadba;}.border-turquoise {border-color: #1cadba;}.text-gray-50 {color: #f9f9f9;}.bg-gray-50 {background-color: #f9f9f9;}.border-gray-50 {border-color: #f9f9f9;}.text-gray-100 {color: #f0f1f2;}.bg-gray-100 {background-color: #f0f1f2;}.border-gray-100 {border-color: #f0f1f2;}.text-gray-200 {color: #e3e4e6;}.bg-gray-200 {background-color: #e3e4e6;}.border-gray-200 {border-color: #e3e4e6;}.text-gray-300 {color: #d7d7d9;}.bg-gray-300 {background-color: #d7d7d9;}.border-gray-300 {border-color: #d7d7d9;}.text-gray-400 {color: #b1b1b3;}.bg-gray-400 {background-color: #b1b1b3;}.border-gray-400 {border-color: #b1b1b3;}.text-gray-500 {color: #969799;}.bg-gray-500 {background-color: #969799;}.border-gray-500 {border-color: #969799;}.text-gray-600 {color: #707173;}.bg-gray-600 {background-color: #707173;}.border-gray-600 {border-color: #707173;}.text-gray-700 {color: #555659;}.bg-gray-700 {background-color: #555659;}.border-gray-700 {border-color: #555659;}.text-gray-800 {color: #3b3d3f;}.bg-gray-800 {background-color: #3b3d3f;}.border-gray-800 {border-color: #3b3d3f;}.text-gray-900 {color: #222326;}.bg-gray-900 {background-color: #222326;}.border-gray-900 {border-color: #222326;}.text-blue-50 {color: #f3faff;}.bg-blue-50 {background-color: #f3faff;}.border-blue-50 {border-color: #f3faff;}.text-red-50 {color: #fff7f7;}.bg-red-50 {background-color: #fff7f7;}.border-red-50 {border-color: #fff7f7;}.text-green-50 {color: #e1fae5;}.bg-green-50 {background-color: #e1fae5;}.border-green-50 {border-color: #e1fae5;}.text-yellow-50 {color: #fff6e5;}.bg-yellow-50 {background-color: #fff6e5;}.border-yellow-50 {border-color: #fff6e5;}.text-blue-100 {color: #e1f3ff;}.bg-blue-100 {background-color: #e1f3ff;}.border-blue-100 {border-color: #e1f3ff;}.text-red-100 {color: #ffe6e6;}.bg-red-100 {background-color: #ffe6e6;}.border-red-100 {border-color: #ffe6e6;}.text-green-100 {color: #d4f5c4;}.bg-green-100 {background-color: #d4f5c4;}.border-green-100 {border-color: #d4f5c4;}.text-yellow-100 {color: #fec;}.bg-yellow-100 {background-color: #fec;}.border-yellow-100 {border-color: #fec;}.text-blue-200 {color: #bfe5ff;}.bg-blue-200 {background-color: #bfe5ff;}.border-blue-200 {border-color: #bfe5ff;}.text-red-200 {color: #ffbfbf;}.bg-red-200 {background-color: #ffbfbf;}.border-red-200 {border-color: #ffbfbf;}.text-green-200 {color: #b4f0a8;}.bg-green-200 {background-color: #b4f0a8;}.border-green-200 {border-color: #b4f0a8;}.text-yellow-200 {color: #ffe5b2;}.bg-yellow-200 {background-color: #ffe5b2;}.border-yellow-200 {border-color: #ffe5b2;}.text-blue-300 {color: #a6daff;}.bg-blue-300 {background-color: #a6daff;}.border-blue-300 {border-color: #a6daff;}.text-red-300 {color: #f99;}.bg-red-300 {background-color: #f99;}.border-red-300 {border-color: #f99;}.text-green-300 {color: #8ae58a;}.bg-green-300 {background-color: #8ae58a;}.border-green-300 {border-color: #8ae58a;}.text-yellow-300 {color: #ffdf88;}.bg-yellow-300 {background-color: #ffdf88;}.border-yellow-300 {border-color: #ffdf88;}.text-blue-400 {color: #4cb5ff;}.bg-blue-400 {background-color: #4cb5ff;}.border-blue-400 {border-color: #4cb5ff;}.text-red-400 {color: #f26161;}.bg-red-400 {background-color: #f26161;}.border-red-400 {border-color: #f26161;}.text-green-400 {color: #61d086;}.bg-green-400 {background-color: #61d086;}.border-green-400 {border-color: #61d086;}.text-yellow-400 {color: #fb3;}.bg-yellow-400 {background-color: #fb3;}.border-yellow-400 {border-color: #fb3;}.text-blue-500 {color: #0c92f3;}.bg-blue-500 {background-color: #0c92f3;}.border-blue-500 {border-color: #0c92f3;}.text-red-500 {color: #d94141;}.bg-red-500 {background-color: #d94141;}.border-red-500 {border-color: #d94141;}.text-green-500 {color: #39bf71;}.bg-green-500 {background-color: #39bf71;}.border-green-500 {border-color: #39bf71;}.text-yellow-500 {color: #ffa60d;}.bg-yellow-500 {background-color: #ffa60d;}.border-yellow-500 {border-color: #ffa60d;}.text-blue-600 {color: #007fd9;}.bg-blue-600 {background-color: #007fd9;}.border-blue-600 {border-color: #007fd9;}.text-red-600 {color: #bf3939;}.bg-red-600 {background-color: #bf3939;}.border-red-600 {border-color: #bf3939;}.text-green-600 {color: #19a654;}.bg-green-600 {background-color: #19a654;}.border-green-600 {border-color: #19a654;}.text-yellow-600 {color: #ff9000;}.bg-yellow-600 {background-color: #ff9000;}.border-yellow-600 {border-color: #ff9000;}.text-blue-700 {color: #0068b3;}.bg-blue-700 {background-color: #0068b3;}.border-blue-700 {border-color: #0068b3;}.text-red-700 {color: #a62929;}.bg-red-700 {background-color: #a62929;}.border-red-700 {border-color: #a62929;}.text-green-700 {color: #0e8c42;}.bg-green-700 {background-color: #0e8c42;}.border-green-700 {border-color: #0e8c42;}.text-yellow-700 {color: #e67600;}.bg-yellow-700 {background-color: #e67600;}.border-yellow-700 {border-color: #e67600;}.text-turquoise-50 {color: #f0fbfc;}.bg-turquoise-50 {background-color: #f0fbfc;}.border-turquoise-50 {border-color: #f0fbfc;}.text-turquoise-100 {color: #d9f7fa;}.bg-turquoise-100 {background-color: #d9f7fa;}.border-turquoise-100 {border-color: #d9f7fa;}.text-turquoise-200 {color: #b8f0f5;}.bg-turquoise-200 {background-color: #b8f0f5;}.border-turquoise-200 {border-color: #b8f0f5;}.text-turquoise-300 {color: #91eaf2;}.bg-turquoise-300 {background-color: #91eaf2;}.border-turquoise-300 {border-color: #91eaf2;}.text-turquoise-400 {color: #33c0cd;}.bg-turquoise-400 {background-color: #33c0cd;}.border-turquoise-400 {border-color: #33c0cd;}.text-turquoise-500 {color: #1cadba;}.bg-turquoise-500 {background-color: #1cadba;}.border-turquoise-500 {border-color: #1cadba;}.text-turquoise-600 {color: #0097a6;}.bg-turquoise-600 {background-color: #0097a6;}.border-turquoise-600 {border-color: #0097a6;}.text-turquoise-700 {color: #007580;}.bg-turquoise-700 {background-color: #007580;}.border-turquoise-700 {border-color: #007580;}.text-turquoise-800 {color: #005e66;}.bg-turquoise-800 {background-color: #005e66;}.border-turquoise-800 {border-color: #005e66;}.text-turquoise-900 {color: #00464d;}.bg-turquoise-900 {background-color: #00464d;}.border-turquoise-900 {border-color: #00464d;}.text-violet-50 {color: #f8ebff;}.bg-violet-50 {background-color: #f8ebff;}.border-violet-50 {border-color: #f8ebff;}.text-violet-100 {color: #f5e0ff;}.bg-violet-100 {background-color: #f5e0ff;}.border-violet-100 {border-color: #f5e0ff;}.text-violet-200 {color: #ebc4ff;}.bg-violet-200 {background-color: #ebc4ff;}.border-violet-200 {border-color: #ebc4ff;}.text-violet-300 {color: #dea2fc;}.bg-violet-300 {background-color: #dea2fc;}.border-violet-300 {border-color: #dea2fc;}.text-violet-400 {color: #bf75e3;}.bg-violet-400 {background-color: #bf75e3;}.border-violet-400 {border-color: #bf75e3;}.text-violet-500 {color: #a452cc;}.bg-violet-500 {background-color: #a452cc;}.border-violet-500 {border-color: #a452cc;}.text-violet-600 {color: #9c2bd4;}.bg-violet-600 {background-color: #9c2bd4;}.border-violet-600 {border-color: #9c2bd4;}.text-violet-700 {color: #801bb2;}.bg-violet-700 {background-color: #801bb2;}.border-violet-700 {border-color: #801bb2;}.text-violet-800 {color: #620e8c;}.bg-violet-800 {background-color: #620e8c;}.border-violet-800 {border-color: #620e8c;}.text-violet-900 {color: #521173;}.bg-violet-900 {background-color: #521173;}.border-violet-900 {border-color: #521173;}.bg-transparent {background: transparent;}.cursor-pointer {cursor: pointer;}.cursor-text {cursor: text;}.cursor-default {cursor: default;}.cursor-inherit {cursor: inherit;}.flex {display: flex;}.flex-column {flex-direction: column;}.flex-row {flex-direction: row;}.flex-row-reverse {flex-direction: row-reverse;}.flex-column-reverse {flex-direction: column-reverse;}.flex-wrap {flex-wrap: wrap;}.flex-nowrap {flex-wrap: nowrap;}.flex-grow {flex: 1 0 auto;}.flex-shrink {flex: 0 1 auto;}.flex-auto {flex: 1 1 auto;min-height: 0;min-width: 0;}.flex-none {flex: none;}.items-start {align-items: flex-start;}.items-end {align-items: flex-end;}.items-center {align-items: center;}.items-baseline {align-items: baseline;}.items-stretch {align-items: stretch;}.self-start {align-self: flex-start;}.self-end {align-self: flex-end;}.self-center {align-self: center;}.self-baseline {align-self: baseline;}.self-stretch {align-self: stretch;}.justify-start {justify-content: flex-start;}.justify-end {justify-content: flex-end;}.justify-center {justify-content: center;}.justify-between {justify-content: space-between;}.justify-around {justify-content: space-around;}.justify-evenly {justify-content: space-evenly;}.content-start {align-content: flex-start;}.content-end {align-content: flex-end;}.content-center {align-content: center;}.content-between {align-content: space-between;}.content-around {align-content: space-around;}.content-stretch {align-content: stretch;}.order-0 {order: 0;}.order-1 {order: 1;}.order-2 {order: 2;}.order-3 {order: 3;}.order-last {order: 99999;}.icon-size-base {height: 16px;width: 16px;}.icon-size-caption,.momentum-body .icon-size-caption {height: 12px;width: 12px;}.identicon-size,.momentum-body .identicon-size {height: 24px;width: 24px;line-height: 24px;}.display-none {display: none;}.display-inline,.inline {display: inline;}.display-block,.block {display: block;}.display-inline-block,.inline-block {display: inline-block;}.display-table,.table {display: table;}.display-table-cell,.table-cell {display: table-cell;}.visibility-hidden {visibility: hidden;}.overflow-hidden {overflow: hidden;}.overflow-scroll {overflow: scroll;}.overflow-auto {overflow: auto;}.overflow-visible {overflow: visible;}.float-left {float: left;}.float-right {float: right;}.fit-width {max-width: 100%;}.bulleted-list {margin-left: 16px;list-style-type: circle;}.bulleted-list li {margin-bottom: 8px;}.m0 {margin: 0;}.mt0 {margin-top: 0;}.mr0 {margin-right: 0;}.mb0 {margin-bottom: 0;}.ml0 {margin-left: 0;}.mx0 {margin-left: 0;margin-right: 0;}.my0 {margin-bottom: 0;margin-top: 0;}.m0_5 {margin: 4px;}.mt0_5 {margin-top: 4px;}.mr0_5 {margin-right: 4px;}.mb0_5 {margin-bottom: 4px;}.ml0_5 {margin-left: 4px;}.mx0_5 {margin-left: 4px;margin-right: 4px;}.my0_5 {margin-bottom: 4px;margin-top: 4px;}.m1 {margin: 8px;}.mt1 {margin-top: 8px;}.mr1 {margin-right: 8px;}.mb1 {margin-bottom: 8px;}.ml1 {margin-left: 8px;}.mx1 {margin-left: 8px;margin-right: 8px;}.my1 {margin-bottom: 8px;margin-top: 8px;}.m1_5 {margin: 12px;}.mt1_5 {margin-top: 12px;}.mr1_5 {margin-right: 12px;}.mb1_5 {margin-bottom: 12px;}.ml1_5 {margin-left: 12px;}.mx1_5 {margin-left: 12px;margin-right: 12px;}.my1_5 {margin-bottom: 12px;margin-top: 12px;}.m2 {margin: 16px;}.mt2 {margin-top: 16px;}.mr2 {margin-right: 16px;}.mb2 {margin-bottom: 16px;}.ml2 {margin-left: 16px;}.mx2 {margin-left: 16px;margin-right: 16px;}.my2 {margin-bottom: 16px;margin-top: 16px;}.m3 {margin: 24px;}.mt3 {margin-top: 24px;}.mr3 {margin-right: 24px;}.mb3 {margin-bottom: 24px;}.ml3 {margin-left: 24px;}.mx3 {margin-left: 24px;margin-right: 24px;}.my3 {margin-bottom: 24px;margin-top: 24px;}.m4 {margin: 32px;}.mt4 {margin-top: 32px;}.mr4 {margin-right: 32px;}.mb4 {margin-bottom: 32px;}.ml4 {margin-left: 32px;}.mx4 {margin-left: 32px;margin-right: 32px;}.my4 {margin-bottom: 32px;margin-top: 32px;}.m5 {margin: 40px;}.mt5 {margin-top: 40px;}.mr5 {margin-right: 40px;}.mb5 {margin-bottom: 40px;}.ml5 {margin-left: 40px;}.mx5 {margin-left: 40px;margin-right: 40px;}.my5 {margin-bottom: 40px;margin-top: 40px;}.m10 {margin: 80px;}.mt10 {margin-top: 80px;}.mr10 {margin-right: 80px;}.mb10 {margin-bottom: 80px;}.ml10 {margin-left: 80px;}.mx10 {margin-left: 80px;margin-right: 80px;}.my10 {margin-bottom: 80px;margin-top: 80px;}.mn1 {margin: -8px;}.mtn1 {margin-top: -8px;}.mrn1 {margin-right: -8px;}.mbn1 {margin-bottom: -8px;}.mln1 {margin-left: -8px;}.mxn1 {margin-left: -8px;margin-right: -8px;}.myn1 {margin-bottom: -8px;margin-top: -8px;}.mxn2 {margin-left: -16px;margin-right: -16px;}.mxn3 {margin-left: -24px;margin-right: -24px;}.mxn4 {margin-left: -32px;margin-right: -32px;}.mt-auto {margin-top: auto;}.mb-auto {margin-bottom: auto;}.my-auto {margin-top: auto;margin-bottom: auto;}.ml-auto {margin-left: auto;}.mr-auto {margin-right: auto;}.mx-auto {margin-left: auto;margin-right: auto;}.opacity-0 {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.opacity-0_1 {opacity: 0.1;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=10)";filter: alpha(opacity=10);}.opacity-0_2 {opacity: 0.2;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=20)";filter: alpha(opacity=20);}.opacity-0_3 {opacity: 0.3;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=30)";filter: alpha(opacity=30);}.opacity-0_4 {opacity: 0.4;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=40)";filter: alpha(opacity=40);}.opacity-0_5 {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.opacity-0_6 {opacity: 0.6;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=60)";filter: alpha(opacity=60);}.opacity-0_7 {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.opacity-0_8 {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.opacity-0_9 {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.opacity-1 {opacity: 1;-ms-filter: none;filter: none;}.outline-none {outline: 0;}.p0 {padding: 0;}.pt0 {padding-top: 0;}.pr0 {padding-right: 0;}.pb0 {padding-bottom: 0;}.pl0 {padding-left: 0;}.px0 {padding-left: 0;padding-right: 0;}.py0 {padding-bottom: 0;padding-top: 0;}.p0_5 {padding: 4px;}.pt0_5 {padding-top: 4px;}.pr0_5 {padding-right: 4px;}.pb0_5 {padding-bottom: 4px;}.pl0_5 {padding-left: 4px;}.px0_5 {padding-left: 4px;padding-right: 4px;}.py0_5 {padding-bottom: 4px;padding-top: 4px;}.p1 {padding: 8px;}.pt1 {padding-top: 8px;}.pr1 {padding-right: 8px;}.pb1 {padding-bottom: 8px;}.pl1 {padding-left: 8px;}.py1 {padding-bottom: 8px;padding-top: 8px;}.px1 {padding-left: 8px;padding-right: 8px;}.p1_5 {padding: 12px;}.pt1_5 {padding-top: 12px;}.pr1_5 {padding-right: 12px;}.pb1_5 {padding-bottom: 12px;}.pl1_5 {padding-left: 12px;}.px1_5 {padding-left: 12px;padding-right: 12px;}.py1_5 {padding-bottom: 12px;padding-top: 12px;}.p2 {padding: 16px;}.pt2 {padding-top: 16px;}.pr2 {padding-right: 16px;}.pb2 {padding-bottom: 16px;}.pl2 {padding-left: 16px;}.py2 {padding-bottom: 16px;padding-top: 16px;}.px2 {padding-left: 16px;padding-right: 16px;}.p3 {padding: 24px;}.pt3 {padding-top: 24px;}.pr3 {padding-right: 24px;}.pb3 {padding-bottom: 24px;}.pl3 {padding-left: 24px;}.py3 {padding-bottom: 24px;padding-top: 24px;}.px3 {padding-left: 24px;padding-right: 24px;}.p4 {padding: 32px;}.pt4 {padding-top: 32px;}.pr4 {padding-right: 32px;}.pb4 {padding-bottom: 32px;}.pl4 {padding-left: 32px;}.py4 {padding-bottom: 32px;padding-top: 32px;}.px4 {padding-left: 32px;padding-right: 32px;}.p5 {padding: 40px;}.pt5 {padding-top: 40px;}.pr5 {padding-right: 40px;}.pb5 {padding-bottom: 40px;}.pl5 {padding-left: 40px;}.py5 {padding-bottom: 40px;padding-top: 40px;}.px5 {padding-left: 40px;padding-right: 40px;}.p10 {padding: 80px;}.pt10 {padding-top: 80px;}.pr10 {padding-right: 80px;}.pb10 {padding-bottom: 80px;}.pl10 {padding-left: 80px;}.py10 {padding-bottom: 80px;padding-top: 80px;}.px10 {padding-left: 80px;padding-right: 80px;}.pointer-events-none {pointer-events: none;}.relative {position: relative;}.absolute {position: absolute;}.sticky {position: sticky;}.top-0 {top: 0;}.right-0 {right: 0;}.bottom-0 {bottom: 0;}.left-0 {left: 0;}.height-full {height: 100%;}.width-full {width: 100%;}.max-width-full {max-width: 100%;}.width-0 {width: 0;}.height-0 {height: 0;}.width-auto {width: auto;}.min-width-1 {min-width: 8px;}.min-height-1 {min-height: 8px;}.max-width-1 {max-width: 8px;}.max-height-1 {max-height: 8px;}.min-width-2 {min-width: 16px;}.min-height-2 {min-height: 16px;}.max-width-2 {max-width: 16px;}.max-height-2 {max-height: 16px;}.min-width-3 {min-width: 24px;}.min-height-3 {min-height: 24px;}.max-width-3 {max-width: 24px;}.max-height-3 {max-height: 24px;}.min-width-4 {min-width: 32px;}.min-height-4 {min-height: 32px;}.max-width-4 {max-width: 32px;}.max-height-4 {max-height: 32px;}.min-width-5 {min-width: 40px;}.min-height-5 {min-height: 40px;}.max-width-5 {max-width: 40px;}.max-height-5 {max-height: 40px;}.min-width-6 {min-width: 48px;}.min-height-6 {min-height: 48px;}.max-width-6 {max-width: 48px;}.max-height-6 {max-height: 48px;}.min-width-7 {min-width: 56px;}.min-height-7 {min-height: 56px;}.max-width-7 {max-width: 56px;}.max-height-7 {max-height: 56px;}.min-width-8 {min-width: 64px;}.min-height-8 {min-height: 64px;}.max-width-8 {max-width: 64px;}.max-height-8 {max-height: 64px;}.min-width-9 {min-width: 72px;}.min-height-9 {min-height: 72px;}.max-width-9 {max-width: 72px;}.max-height-9 {max-height: 72px;}.min-width-10 {min-width: 80px;}.min-height-10 {min-height: 80px;}.max-width-10 {max-width: 80px;}.max-height-10 {max-height: 80px;}.min-width-11 {min-width: 88px;}.min-height-11 {min-height: 88px;}.max-width-11 {max-width: 88px;}.max-height-11 {max-height: 88px;}.min-width-12 {min-width: 96px;}.min-height-12 {min-height: 96px;}.max-width-12 {max-width: 96px;}.max-height-12 {max-height: 96px;}.min-width-13 {min-width: 104px;}.min-height-13 {min-height: 104px;}.max-width-13 {max-width: 104px;}.max-height-13 {max-height: 104px;}.min-width-14 {min-width: 112px;}.min-height-14 {min-height: 112px;}.max-width-14 {max-width: 112px;}.max-height-14 {max-height: 112px;}.min-width-15 {min-width: 120px;}.min-height-15 {min-height: 120px;}.max-width-15 {max-width: 120px;}.max-height-15 {max-height: 120px;}.min-width-16 {min-width: 128px;}.min-height-16 {min-height: 128px;}.max-width-16 {max-width: 128px;}.max-height-16 {max-height: 128px;}.min-width-17 {min-width: 136px;}.min-height-17 {min-height: 136px;}.max-width-17 {max-width: 136px;}.max-height-17 {max-height: 136px;}.min-width-18 {min-width: 144px;}.min-height-18 {min-height: 144px;}.max-width-18 {max-width: 144px;}.max-height-18 {max-height: 144px;}.min-width-19 {min-width: 152px;}.min-height-19 {min-height: 152px;}.max-width-19 {max-width: 152px;}.max-height-19 {max-height: 152px;}.min-width-20 {min-width: 160px;}.min-height-20 {min-height: 160px;}.max-width-20 {max-width: 160px;}.max-height-20 {max-height: 160px;}.min-width-21 {min-width: 168px;}.min-height-21 {min-height: 168px;}.max-width-21 {max-width: 168px;}.max-height-21 {max-height: 168px;}.min-width-22 {min-width: 176px;}.min-height-22 {min-height: 176px;}.max-width-22 {max-width: 176px;}.max-height-22 {max-height: 176px;}.min-width-23 {min-width: 184px;}.min-height-23 {min-height: 184px;}.max-width-23 {max-width: 184px;}.max-height-23 {max-height: 184px;}.min-width-24 {min-width: 192px;}.min-height-24 {min-height: 192px;}.max-width-24 {max-width: 192px;}.max-height-24 {max-height: 192px;}.min-width-25 {min-width: 200px;}.min-height-25 {min-height: 200px;}.max-width-25 {max-width: 200px;}.max-height-25 {max-height: 200px;}.min-width-26 {min-width: 208px;}.min-height-26 {min-height: 208px;}.max-width-26 {max-width: 208px;}.max-height-26 {max-height: 208px;}.min-width-27 {min-width: 216px;}.min-height-27 {min-height: 216px;}.max-width-27 {max-width: 216px;}.max-height-27 {max-height: 216px;}.min-width-28 {min-width: 224px;}.min-height-28 {min-height: 224px;}.max-width-28 {max-width: 224px;}.max-height-28 {max-height: 224px;}.min-width-29 {min-width: 232px;}.min-height-29 {min-height: 232px;}.max-width-29 {max-width: 232px;}.max-height-29 {max-height: 232px;}.min-width-30 {min-width: 240px;}.min-height-30 {min-height: 240px;}.max-width-30 {max-width: 240px;}.max-height-30 {max-height: 240px;}.min-width-40 {min-width: 320px;}.min-height-40 {min-height: 320px;}.max-width-40 {max-width: 320px;}.max-height-40 {max-height: 320px;}.min-width-50 {min-width: 400px;}.min-height-50 {min-height: 400px;}.max-width-50 {max-width: 400px;}.max-height-50 {max-height: 400px;}.min-width-60 {min-width: 480px;}.min-height-60 {min-height: 480px;}.max-width-60 {max-width: 480px;}.max-height-60 {max-height: 480px;}.min-width-70 {min-width: 560px;}.min-height-70 {min-height: 560px;}.max-width-70 {max-width: 560px;}.max-height-70 {max-height: 560px;}.min-width-80 {min-width: 640px;}.min-height-80 {min-height: 640px;}.max-width-80 {max-width: 640px;}.max-height-80 {max-height: 640px;}.min-width-90 {min-width: 720px;}.min-height-90 {min-height: 720px;}.max-width-90 {max-width: 720px;}.max-height-90 {max-height: 720px;}.min-width-100 {min-width: 800px;}.min-height-100 {min-height: 800px;}.max-width-100 {max-width: 800px;}.max-height-100 {max-height: 800px;}.min-width-110 {min-width: 880px;}.min-height-110 {min-height: 880px;}.max-width-110 {max-width: 880px;}.max-height-110 {max-height: 880px;}.min-width-120 {min-width: 960px;}.min-height-120 {min-height: 960px;}.max-width-120 {max-width: 960px;}.max-height-120 {max-height: 960px;}.min-width-36 {min-width: 288px;}.max-height-51 {max-height: 408px;}.max-height-inherit {max-height: inherit;}.valign-baseline {vertical-align: baseline;}.valign-text-top {vertical-align: text-top;}.valign-top {vertical-align: top;}.valign-middle {vertical-align: middle;}.valign-bottom {vertical-align: bottom;}.font-family-inherit {font-family: inherit;}.font-size-inherit {font-size: inherit;}.text-decoration-none {text-decoration: none;}.bold {font-weight: bold;}.regular {font-weight: normal;}.italic {font-style: italic;}.strikethrough {text-decoration: line-through;}.underline {text-decoration: underline;}.caps {text-transform: uppercase;letter-spacing: 1px;}.lowercase {text-transform: lowercase;}.capitalize {text-transform: capitalize;}.align-left {text-align: left;}.align-center {text-align: center;}.align-right {text-align: right;}.align-justify {text-align: justify;}.nowrap {white-space: nowrap;}.break-word {word-wrap: break-word;}.line-height-1 {line-height: 24px;}.line-height-2 {line-height: 48px;}.line-height-3 {line-height: 72px;}.line-height-4 {line-height: 96px;}.list-style-none {list-style: none;}.ellipsis {overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;white-space: nowrap;}.list-reset {list-style: none;padding-left: 0;}.text-overflow-initial {-o-text-overflow: initial;text-overflow: initial;}.transition-property-all {-webkit-transition-property: all;-moz-transition-property: all;-o-transition-property: all;-ms-transition-property: all;transition-property: all;}.transition-property-opacity {-webkit-transition-property: opacity;-moz-transition-property: opacity;-o-transition-property: opacity;-ms-transition-property: opacity;transition-property: opacity;}.transition-duration-sec1 {-webkit-transition-duration: 1s;-moz-transition-duration: 1s;-o-transition-duration: 1s;-ms-transition-duration: 1s;transition-duration: 1s;}.transition-duration-sec1_5 {-webkit-transition-duration: 1.5s;-moz-transition-duration: 1.5s;-o-transition-duration: 1.5s;-ms-transition-duration: 1.5s;transition-duration: 1.5s;}.transition-duration-sec2 {-webkit-transition-duration: 2s;-moz-transition-duration: 2s;-o-transition-duration: 2s;-ms-transition-duration: 2s;transition-duration: 2s;}.transition-duration-sec2_5 {-webkit-transition-duration: 2.5s;-moz-transition-duration: 2.5s;-o-transition-duration: 2.5s;-ms-transition-duration: 2.5s;transition-duration: 2.5s;}.transition-duration-sec3 {-webkit-transition-duration: 3s;-moz-transition-duration: 3s;-o-transition-duration: 3s;-ms-transition-duration: 3s;transition-duration: 3s;}.transition-duration-sec3_5 {-webkit-transition-duration: 3.5s;-moz-transition-duration: 3.5s;-o-transition-duration: 3.5s;-ms-transition-duration: 3.5s;transition-duration: 3.5s;}.transition-duration-sec4 {-webkit-transition-duration: 4s;-moz-transition-duration: 4s;-o-transition-duration: 4s;-ms-transition-duration: 4s;transition-duration: 4s;}.transition-duration-sec4_5 {-webkit-transition-duration: 4.5s;-moz-transition-duration: 4.5s;-o-transition-duration: 4.5s;-ms-transition-duration: 4.5s;transition-duration: 4.5s;}.transition-duration-sec5 {-webkit-transition-duration: 5s;-moz-transition-duration: 5s;-o-transition-duration: 5s;-ms-transition-duration: 5s;transition-duration: 5s;}.transition-duration-sec6 {-webkit-transition-duration: 6s;-moz-transition-duration: 6s;-o-transition-duration: 6s;-ms-transition-duration: 6s;transition-duration: 6s;}.transition-duration-sec7 {-webkit-transition-duration: 7s;-moz-transition-duration: 7s;-o-transition-duration: 7s;-ms-transition-duration: 7s;transition-duration: 7s;}.transition-duration-sec8 {-webkit-transition-duration: 8s;-moz-transition-duration: 8s;-o-transition-duration: 8s;-ms-transition-duration: 8s;transition-duration: 8s;}.transition-duration-sec9 {-webkit-transition-duration: 9s;-moz-transition-duration: 9s;-o-transition-duration: 9s;-ms-transition-duration: 9s;transition-duration: 9s;}.transition-duration-sec10 {-webkit-transition-duration: 10s;-moz-transition-duration: 10s;-o-transition-duration: 10s;-ms-transition-duration: 10s;transition-duration: 10s;}.transition-duration-ms100 {-webkit-transition-duration: 100ms;-moz-transition-duration: 100ms;-o-transition-duration: 100ms;-ms-transition-duration: 100ms;transition-duration: 100ms;}.transition-duration-ms200 {-webkit-transition-duration: 200ms;-moz-transition-duration: 200ms;-o-transition-duration: 200ms;-ms-transition-duration: 200ms;transition-duration: 200ms;}.transition-duration-ms300 {-webkit-transition-duration: 300ms;-moz-transition-duration: 300ms;-o-transition-duration: 300ms;-ms-transition-duration: 300ms;transition-duration: 300ms;}.transition-duration-ms400 {-webkit-transition-duration: 400ms;-moz-transition-duration: 400ms;-o-transition-duration: 400ms;-ms-transition-duration: 400ms;transition-duration: 400ms;}.transition-duration-ms500 {-webkit-transition-duration: 500ms;-moz-transition-duration: 500ms;-o-transition-duration: 500ms;-ms-transition-duration: 500ms;transition-duration: 500ms;}.transition-duration-ms600 {-webkit-transition-duration: 600ms;-moz-transition-duration: 600ms;-o-transition-duration: 600ms;-ms-transition-duration: 600ms;transition-duration: 600ms;}.transition-duration-ms700 {-webkit-transition-duration: 700ms;-moz-transition-duration: 700ms;-o-transition-duration: 700ms;-ms-transition-duration: 700ms;transition-duration: 700ms;}.transition-duration-ms800 {-webkit-transition-duration: 800ms;-moz-transition-duration: 800ms;-o-transition-duration: 800ms;-ms-transition-duration: 800ms;transition-duration: 800ms;}.transition-duration-ms900 {-webkit-transition-duration: 900ms;-moz-transition-duration: 900ms;-o-transition-duration: 900ms;-ms-transition-duration: 900ms;transition-duration: 900ms;}.transition-tf-ease {-webkit-transition-timing-function: ease;-moz-transition-timing-function: ease;-o-transition-timing-function: ease;-ms-transition-timing-function: ease;transition-timing-function: ease;}.transition-tf-linear {-webkit-transition-timing-function: linear;-moz-transition-timing-function: linear;-o-transition-timing-function: linear;-ms-transition-timing-function: linear;transition-timing-function: linear;}.transition-tf-ease-in {-webkit-transition-timing-function: ease-in;-moz-transition-timing-function: ease-in;-o-transition-timing-function: ease-in;-ms-transition-timing-function: ease-in;transition-timing-function: ease-in;}.transition-tf-ease-out {-webkit-transition-timing-function: ease-out;-moz-transition-timing-function: ease-out;-o-transition-timing-function: ease-out;-ms-transition-timing-function: ease-out;transition-timing-function: ease-out;}.transition-tf-ease-in-out {-webkit-transition-timing-function: ease-in-out;-moz-transition-timing-function: ease-in-out;-o-transition-timing-function: ease-in-out;-ms-transition-timing-function: ease-in-out;transition-timing-function: ease-in-out;}.transition-tf-step-start {-webkit-transition-timing-function: step-start;-moz-transition-timing-function: step-start;-o-transition-timing-function: step-start;-ms-transition-timing-function: step-start;transition-timing-function: step-start;}.transition-tf-step-end {-webkit-transition-timing-function: step-end;-moz-transition-timing-function: step-end;-o-transition-timing-function: step-end;-ms-transition-timing-function: step-end;transition-timing-function: step-end;}.transition-delay-sec1 {-webkit-transition-delay: 1s;-moz-transition-delay: 1s;-o-transition-delay: 1s;-ms-transition-delay: 1s;transition-delay: 1s;}.transition-delay-sec1_5 {-webkit-transition-delay: 1.5s;-moz-transition-delay: 1.5s;-o-transition-delay: 1.5s;-ms-transition-delay: 1.5s;transition-delay: 1.5s;}.transition-delay-sec2 {-webkit-transition-delay: 2s;-moz-transition-delay: 2s;-o-transition-delay: 2s;-ms-transition-delay: 2s;transition-delay: 2s;}.transition-delay-sec2_5 {-webkit-transition-delay: 2.5s;-moz-transition-delay: 2.5s;-o-transition-delay: 2.5s;-ms-transition-delay: 2.5s;transition-delay: 2.5s;}.transition-delay-sec3 {-webkit-transition-delay: 3s;-moz-transition-delay: 3s;-o-transition-delay: 3s;-ms-transition-delay: 3s;transition-delay: 3s;}.transition-delay-sec3_5 {-webkit-transition-delay: 3.5s;-moz-transition-delay: 3.5s;-o-transition-delay: 3.5s;-ms-transition-delay: 3.5s;transition-delay: 3.5s;}.transition-delay-sec4 {-webkit-transition-delay: 4s;-moz-transition-delay: 4s;-o-transition-delay: 4s;-ms-transition-delay: 4s;transition-delay: 4s;}.transition-delay-sec4_5 {-webkit-transition-delay: 4.5s;-moz-transition-delay: 4.5s;-o-transition-delay: 4.5s;-ms-transition-delay: 4.5s;transition-delay: 4.5s;}.transition-delay-sec5 {-webkit-transition-delay: 5s;-moz-transition-delay: 5s;-o-transition-delay: 5s;-ms-transition-delay: 5s;transition-delay: 5s;}.transition-delay-sec6 {-webkit-transition-delay: 6s;-moz-transition-delay: 6s;-o-transition-delay: 6s;-ms-transition-delay: 6s;transition-delay: 6s;}.transition-delay-sec7 {-webkit-transition-delay: 7s;-moz-transition-delay: 7s;-o-transition-delay: 7s;-ms-transition-delay: 7s;transition-delay: 7s;}.transition-delay-sec8 {-webkit-transition-delay: 8s;-moz-transition-delay: 8s;-o-transition-delay: 8s;-ms-transition-delay: 8s;transition-delay: 8s;}.transition-delay-sec9 {-webkit-transition-delay: 9s;-moz-transition-delay: 9s;-o-transition-delay: 9s;-ms-transition-delay: 9s;transition-delay: 9s;}.transition-delay-sec10 {-webkit-transition-delay: 10s;-moz-transition-delay: 10s;-o-transition-delay: 10s;-ms-transition-delay: 10s;transition-delay: 10s;}.transition-delay-ms100 {-webkit-transition-delay: 100ms;-moz-transition-delay: 100ms;-o-transition-delay: 100ms;-ms-transition-delay: 100ms;transition-delay: 100ms;}.transition-delay-ms200 {-webkit-transition-delay: 200ms;-moz-transition-delay: 200ms;-o-transition-delay: 200ms;-ms-transition-delay: 200ms;transition-delay: 200ms;}.transition-delay-ms300 {-webkit-transition-delay: 300ms;-moz-transition-delay: 300ms;-o-transition-delay: 300ms;-ms-transition-delay: 300ms;transition-delay: 300ms;}.transition-delay-ms400 {-webkit-transition-delay: 400ms;-moz-transition-delay: 400ms;-o-transition-delay: 400ms;-ms-transition-delay: 400ms;transition-delay: 400ms;}.transition-delay-ms500 {-webkit-transition-delay: 500ms;-moz-transition-delay: 500ms;-o-transition-delay: 500ms;-ms-transition-delay: 500ms;transition-delay: 500ms;}.transition-delay-ms600 {-webkit-transition-delay: 600ms;-moz-transition-delay: 600ms;-o-transition-delay: 600ms;-ms-transition-delay: 600ms;transition-delay: 600ms;}.transition-delay-ms700 {-webkit-transition-delay: 700ms;-moz-transition-delay: 700ms;-o-transition-delay: 700ms;-ms-transition-delay: 700ms;transition-delay: 700ms;}.transition-delay-ms800 {-webkit-transition-delay: 800ms;-moz-transition-delay: 800ms;-o-transition-delay: 800ms;-ms-transition-delay: 800ms;transition-delay: 800ms;}.transition-delay-ms900 {-webkit-transition-delay: 900ms;-moz-transition-delay: 900ms;-o-transition-delay: 900ms;-ms-transition-delay: 900ms;transition-delay: 900ms;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5 {color: #fff;}.theme-inverse a {color: inherit;}.theme-inverse a:hover {color: #a6daff;}.theme-inverse a:active {color: #bfe5ff;}.theme-inverse a.text-muted {color: #b1b1b3;}.theme-inverse hr {background: #555659;}.theme-inverse .mo-identicon {background-color: #555659;color: #fff;}.theme-inverse .menu-row.hover {background: #222326;}.theme-inverse .menu-row.active {color: #fff;background: #222326;}.theme-inverse .menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse a.menu-row {color: inherit;}.theme-inverse a.menu-row:hover {background: #222326;}.theme-inverse a.menu-row:active {color: #fff;background: #222326;}.theme-inverse .menu-divider {border-color: #555659;}.theme-inverse .text-color-heading {color: #fff;}.theme-inverse .text-color-body {color: #d7d7d9;}.theme-inverse .text-muted {color: #b1b1b3;}.theme-inverse .text-positive {color: #8ae58a;}.theme-inverse .text-muted-positive {color: #39bf71;}.theme-inverse .text-negative {color: #f99;}.theme-inverse .text-muted-negative {color: #f26161;}.theme-inverse .nav-link,.momentum-body .theme-inverse .nav-link {color: #b1b1b3;}.theme-inverse .nav-link:hover,.momentum-body .theme-inverse .nav-link:hover {color: #a6daff;}.theme-inverse .nav-link:active,.momentum-body .theme-inverse .nav-link:active {color: #bfe5ff;}.theme-inverse a.tab-link,.momentum-body .theme-inverse a.tab-link {color: #d7d7d9;}.theme-inverse a.tab-link:hover,.momentum-body .theme-inverse a.tab-link:hover {border-bottom-color: #969799;color: #fff;}.theme-inverse a.tab-link:active,.momentum-body .theme-inverse a.tab-link:active {border-bottom-color: #d7d7d9;color: #d7d7d9;}.theme-inverse a.tab-link.selected,.momentum-body .theme-inverse a.tab-link.selected {color: #fff;}.theme-inverse .list-row {border-bottom: 1px solid #555659;border-top: 1px solid #555659;}.theme-inverse .upload {background-color: #3b3d3f;border-color: #555659;color: #969799;}.theme-inverse .upload:hover,.theme-inverse .upload.hover {background-color: #707173;}.theme-inverse .border {border-color: #555659;}.theme-inverse .border-top {border-top-color: #555659;}.theme-inverse .border-right {border-right-color: #555659;}.theme-inverse .border-bottom {border-bottom-color: #555659;}.theme-inverse .border-left {border-left-color: #555659;}@media (max-width: 575px) {.display-none-xs {display: none;}.display-inline-xs,.inline-xs {display: inline;}.display-block-cx,.block-xs {display: block;}.display-inline-block-xs,.inline-block-xs {display: inline-block;}.display-table-xs,.table-xs {display: table;}.display-table-cell-xs,.table-cell-xs {display: table-cell;}.display-flex-xs,.flex-xs {display: flex;}}@media (min-width: 576px) {.container,.container-sm {max-width: 540px;width: auto;}.col-sm {flex: 1 1 0%;min-width: 0;width: 100%;}.col-sm-auto {flex: 0 0 auto;width: auto;}.col-sm-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-sm-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-sm-3 {flex: 0 0 25%;max-width: 25%;}.col-sm-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-sm-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-sm-6 {flex: 0 0 50%;max-width: 50%;}.col-sm-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-sm-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-sm-9 {flex: 0 0 75%;max-width: 75%;}.col-sm-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-sm-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-sm-12 {flex: 0 0 100%;max-width: 100%;}.display-none-sm {display: none;}.display-inline-sm {display: inline;}.display-block-sm {display: block;}.display-inline-block-sm {display: inline-block;}.display-table-sm {display: table;}.display-table-cell-sm {display: table-cell;}.display-flex-sm {display: flex;}}@media (min-width: 768px) {.container,.container-sm,.container-md {max-width: 720px;width: auto;}.col-md {flex: 1 1 0%;min-width: 0;width: 100%;}.col-md-auto {flex: 0 0 auto;width: auto;}.col-md-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-md-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-md-3 {flex: 0 0 25%;max-width: 25%;}.col-md-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-md-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-md-6 {flex: 0 0 50%;max-width: 50%;}.col-md-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-md-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-md-9 {flex: 0 0 75%;max-width: 75%;}.col-md-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-md-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-md-12 {flex: 0 0 100%;max-width: 100%;}.display-none-md {display: none;}.display-inline-md {display: inline;}.display-block-md {display: block;}.display-inline-block-md {display: inline-block;}.display-table-md {display: table;}.display-table-cell-md {display: table-cell;}.display-flex-md {display: flex;}}@media (min-width: 992px) {.container,.container-sm,.container-md,.container-lg {max-width: 960px;width: auto;}.col-lg {flex: 1 1 0%;min-width: 0;width: 100%;}.col-lg-auto {flex: 0 0 auto;width: auto;}.col-lg-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-lg-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-lg-3 {flex: 0 0 25%;max-width: 25%;}.col-lg-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-lg-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-lg-6 {flex: 0 0 50%;max-width: 50%;}.col-lg-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-lg-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-lg-9 {flex: 0 0 75%;max-width: 75%;}.col-lg-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-lg-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-lg-12 {flex: 0 0 100%;max-width: 100%;}.display-none-lg {display: none;}.display-inline-lg {display: inline;}.display-block-lg {display: block;}.display-inline-block-lg {display: inline-block;}.display-table-lg {display: table;}.display-table-cell-lg {display: table-cell;}.display-flex-lg {display: flex;}}@media (min-width: 1200px) {.container,.container-sm,.container-md,.container-lg,.container-xl {max-width: 1140px;width: auto;}.col-xl {flex: 1 1 0%;min-width: 0;width: 100%;}.col-xl-auto {flex: 0 0 auto;width: auto;}.col-xl-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-xl-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-xl-3 {flex: 0 0 25%;max-width: 25%;}.col-xl-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-xl-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-xl-6 {flex: 0 0 50%;max-width: 50%;}.col-xl-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-xl-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-xl-9 {flex: 0 0 75%;max-width: 75%;}.col-xl-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-xl-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-xl-12 {flex: 0 0 100%;max-width: 100%;}.display-none-xl {display: none;}.display-inline-xl {display: inline;}.display-block-xl {display: block;}.display-inline-block-xl {display: inline-block;}.display-table-xl {display: table;}.display-table-cell-xl {display: table-cell;}.display-flex-xl {display: flex;}}html {position: relative;min-height: 100%;}body {background: #f9f9f9;color: #515357;padding-top: 70px;padding-bottom: 250px;}a,a:visited {color: #737578;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.ttf") format('truetype');font-style: normal;font-weight: bold;text-rendering: optimizeLegibility;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.ttf") format('truetype');font-style: normal;font-weight: normal;text-rendering: optimizeLegibility;}body,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {color: #515357;font: normal 400 16px/1.8 Lato;}h1,h2,h3,h4,p,h5,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;display: block;}h1 {font: normal 700 48px/1.4 Lato;color: #fff;text-transform: uppercase;letter-spacing: 1px;}h2,h5 {font: normal 400 36px/1.4 Lato;color: #515357;text-transform: none;letter-spacing: 0px;}h3 {font: normal 700 18px/1.4 "Lato";color: #515357;}h4 {font: normal 700 16px/1.4 Lato;text-transform: uppercase;letter-spacing: 1px;color: #515357;}h5 {font-size: 24px;margin-right: 115px;overflow: hidden;-webkit-transition: color 150ms;-moz-transition: color 150ms;-o-transition: color 150ms;-ms-transition: color 150ms;transition: color 150ms;}h2,h3,h4 {margin: 17.5px 0;}p,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 17.5px 0;}p > a,.postings-link {text-decoration: underline;color: #737578;}p > a:hover,.postings-link:hover {color: #579eee;}p > a:active,.postings-link:active,p > a:focus,.postings-link:focus {color: #3c6ea6;}.page-full-width {width: 100%;}.page-centered,.g-recaptcha div,.h-captcha-spacing {display: block;margin: 0 auto;max-width: 1080px;}.content-wrapper {min-height: 100%;}.content {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;min-height: 100%;position: relative;width: 100%;}.row {left: 0;position: absolute;right: 0;}.column-wrapper {display: table;height: 100%;width: 100%;}.table-row {display: table-row;}.column {display: table-cell;position: relative;vertical-align: middle;}.third {width: 33.33%;}.two-thirds {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;padding-left: 40px;width: 66.67%;}.section-wrapper {padding: 0 30px;}.section {padding: 20px 0;position: relative;}.narrow-section,.application .section,.eeo-survey .section,.list .section,.show .section {max-width: 760px;padding-left: 0;padding-right: 0;}.accent-section {background: #fff;}.accent-section.small-accent {padding: 0 30px;}.accent-section .posting-categories {margin: 20px 0;}.accent-section .posting-category {display: inline-block;font-size: 14px;margin-right: 10px;}.split-width-container,.show .posting-header {display: block;}.left-block,.right-block,.left-float,.right-float,.full-block {display: block;width: auto;}.left-block {overflow: hidden;}.right-float {float: right;margin-left: 10px;}.right-block {overflow: hidden;}.left-float {float: left;margin-right: 10px;}.full-block {width: 100%;}.template-btn,.template-btn-submit,.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {font: normal 700 14px/1.4 Lato;text-transform: uppercase;letter-spacing: 2px;text-align: center;border-radius: 3px;color: #fff;background: #00a1dc;height: auto;position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 10px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.template-btn .filename,.template-btn-submit .filename,.template-btn-utility .filename,.sort-category .filename,.application .application-field .upload-file-overlay .filename,.eeo-survey .application-field .upload-file-overlay .filename,.list .filter-button-wrapper .filter-button .filename,.template-btn .default-label,.template-btn-submit .default-label,.template-btn-utility .default-label,.sort-category .default-label,.application .application-field .upload-file-overlay .default-label,.eeo-survey .application-field .upload-file-overlay .default-label,.list .filter-button-wrapper .filter-button .default-label {line-height: 1.33;display: block;overflow: hidden;}.template-btn:visited,.template-btn-submit:visited,.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {color: #fff;}.template-btn .icon >svg,.template-btn-submit .icon >svg,.template-btn-utility .icon >svg,.sort-category .icon >svg,.application .application-field .upload-file-overlay .icon >svg,.eeo-survey .application-field .upload-file-overlay .icon >svg,.list .filter-button-wrapper .filter-button .icon >svg {fill: #fff;}.template-btn:hover,.template-btn-submit:hover,.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {color: #fff;}.template-btn:active,.template-btn-submit:active,.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #00709a;}.template-btn-submit {color: #fff;background: #00a1dc;border-color: #0098d1;}.template-btn-submit .icon >svg {fill: #fff;}.template-btn-submit:visited {color: #fff;}.template-btn-submit:hover {background: #0090c6;}.template-btn-submit:active,.template-btn-submit:focus {background: #00709a;}.template-btn-submit.cerulean {background-color: #0c92f3;border-color: #0b8ae6;}.template-btn-submit.cerulean:hover {background: #0a83da;}.template-btn-submit.cerulean:active,.template-btn-submit.cerulean:focus {background: #0866aa;}.template-btn-submit.teal {background-color: #1cadba;border-color: #1aa4b0;}.template-btn-submit.teal:hover {background: #199ba7;}.template-btn-submit.teal:active,.template-btn-submit.teal:focus {background: #137982;}.template-btn-submit.shamrock {background-color: #39bf71;border-color: #36b56b;}.template-btn-submit.shamrock:hover {background: #33ab65;}.template-btn-submit.shamrock:active,.template-btn-submit.shamrock:focus {background: #27854f;}.template-btn-submit.golden-poppy {background-color: #ffa60d;border-color: #f29d0c;}.template-btn-submit.golden-poppy:hover {background: #e5950b;}.template-btn-submit.golden-poppy:active,.template-btn-submit.golden-poppy:focus {background: #b27409;}.template-btn-submit.ruby {background-color: #d94141;border-color: #ce3d3d;}.template-btn-submit.ruby:hover {background: #c33a3a;}.template-btn-submit.ruby:active,.template-btn-submit.ruby:focus {background: #972d2d;}.template-btn-submit.ash {background-color: #969799;border-color: #8e8f91;}.template-btn-submit.ash:hover {background: #878789;}.template-btn-submit.ash:active,.template-btn-submit.ash:focus {background: #69696b;}.template-btn-submit.black {background-color: #000;border-color: #000;}.template-btn-submit.black:hover {background: #000;}.template-btn-submit.black:active,.template-btn-submit.black:focus {background: #000;}.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {background: #ebecf0;color: #9696a2;border: 1px solid #dfe0e4;}.template-btn-utility >svg,.sort-category >svg,.application .application-field .upload-file-overlay >svg,.eeo-survey .application-field .upload-file-overlay >svg,.list .filter-button-wrapper .filter-button >svg {fill: #9696a2;}.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited {color: #9696a2;background: #ebecf0;}.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {background: #dfe0e4;color: #5a5a61;}.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #d3d4d8;color: #5a5a61;}.template-btn-utility.has-file,.sort-category.has-file,.application .application-field .upload-file-overlay.has-file,.eeo-survey .application-field .upload-file-overlay.has-file,.list .filter-button-wrapper .filter-button.has-file {background: #dadbdf;}.template-btn .icon,.template-btn-submit .icon,.template-btn-utility .icon,.sort-category .icon,.application .application-field .upload-file-overlay .icon,.eeo-survey .application-field .upload-file-overlay .icon,.list .filter-button-wrapper .filter-button .icon {position: absolute;left: 15px;top: calc(50% - 8px);}.posting-btn-submit {padding: 5px 15px;}.main-header {background: #fff;color: #515357;}.main-header.section-wrapper,.main-header .section {padding-top: 0px;padding-bottom: 0px;}.main-header .main-header-logo {margin: 17.5px 0px;display: inline-block;}.main-header .main-header-logo img {height: 35px;}.main-header .mobile-menu svg >path {fill: #515357;}.main-header .main-header-content {display: block;height: 100%;margin: 0px auto;color: #515357;}.main-header .main-header-content .main-header-company {display: inline-block;height: 70px;vertical-align: middle;font-family: Lato;color: #515357;}.main-header {top: 0;height: 70px;}.main-header .main-logo,.main-header .mobile-menu {position: absolute;left: 30px;}.main-header .main-logo img,.main-header .mobile-menu img {height: 100%;position: absolute;}.main-header .main-logo {top: 50%;margin-top: -0.175px;height: 0.5;}.main-header .mobile-menu {position: absolute;right: 0px;top: 50%;margin-top: -0.15px;height: 0.6;left: auto;right: 30px;}.main-header .mobile-menu img {right: 0px;}.main-header .main-header-content .main-header-company {line-height: 70px;}.main-header .main-header-content .main-header-company .icon,.main-header .main-header-content .main-header-company span {height: 70px;display: inline-block;float: left;height: 70px;}.main-header .main-header-content .main-header-company .icon {margin-right: 10px;}@media screen {.main-header {position: fixed;z-index: 100;top: 0;overflow: hidden;}}.header-comfortable {margin-top: 40px;}.header-comfortable .main-header-logo img {height: 77px;}.header-comfortable .main-header {height: 110px;}.main-footer {margin: 0;color: #7f838a;background: #edeef1;}.main-footer .image-link {display: inline-block;color: #7f838a;margin: 40px 0px;}.main-footer .image-link span,.main-footer .image-link img {display: inline-block;position: relative;height: 24px;}.main-footer .image-link span {margin-right: 10px;}.main-footer .image-link img {vertical-align: -6px;}.main-footer .image-link:hover,.main-footer .image-link:visited {color: #7f838a;}.main-footer p {color: #7f838a;}.main-footer a {color: #579eee;border-bottom: 1px solid #78b1f1;text-decoration: none;}.main-footer a:visited {color: #579eee;}.main-footer a:hover {color: #4e8ed6;}.main-footer a.image-link {border-bottom: none;}.main-footer {position: absolute;bottom: 0;width: 100%;height: 250px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.main-footer-text {text-align: center;padding: 40px 30px;}.main-footer-text p {display: block;max-width: 500px;margin: 0px auto;}.posting-header h2 {margin-top: 0px;}.posting-page .section.page-centered li {margin: 8px 0px 8px 17px;list-style-position: outside;}.posting-page .section.page-centered ul li {list-style-type: disc;}.medium-utility-label,.small-utility-label {color: #808080;font: normal 700 16px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.large-category-label,.medium-category-label,.small-category-label,.button-utility-label {color: #808080;font: normal 700 24px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.medium-category-label,.button-utility-label {font-size: 14px;}.small-utility-label {font-size: 12px;line-height: 1.4;}.large-category-header {font: normal 700 30px/1.4 Lato;letter-spacing: 1px;margin-bottom: 25px;text-transform: uppercase;}.medium-category-label.capitalize-labels {text-transform: capitalize;}.small-category-label {font-size: 12px;line-height: 1.4;}.button-utility-label {text-transform: none;}.vertical-line,.horizontal-line {border-color: #e2e2e2;}.vertical-line {position: absolute;left: 0px;top: 30%;height: 40%;width: 1px;border-left-width: 1px;border-left-style: solid;}.horizontal-line {margin: 20px auto 20px auto;width: 80px;height: 1px;border-bottom-width: 1px;border-bottom-style: solid;}.confirmation-message {text-align: center;}.confirmation-message .template-btn-submit {margin-top: 16px;}.cc-window{opacity:1;-webkit-transition:opacity 1s ease;transition:opacity 1s ease}.cc-window.cc-invisible{opacity:0}.cc-animate.cc-revoke{-webkit-transition:transform 1s ease;-webkit-transition:-webkit-transform 1s ease;transition:-webkit-transform 1s ease;transition:transform 1s ease;transition:transform 1s ease,-webkit-transform 1s ease}.cc-animate.cc-revoke.cc-top{-webkit-transform:translateY(-2em);transform:translateY(-2em)}.cc-animate.cc-revoke.cc-bottom{-webkit-transform:translateY(2em);transform:translateY(2em)}.cc-animate.cc-revoke.cc-active.cc-top{-webkit-transform:translateY(0);transform:translateY(0)}.cc-animate.cc-revoke.cc-active.cc-bottom{-webkit-transform:translateY(0);transform:translateY(0)}.cc-revoke:hover{-webkit-transform:translateY(0);transform:translateY(0)}.cc-grower{max-height:0;overflow:hidden;-webkit-transition:max-height 1s;transition:max-height 1s}.cc-revoke,.cc-window{position:fixed;overflow:hidden;-webkit-box-sizing:border-box;box-sizing:border-box;font-family:Helvetica,Calibri,Arial,sans-serif;font-size:16px;line-height:1.5em;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:nowrap;flex-wrap:nowrap;z-index:9999}.cc-window.cc-static{position:static}.cc-window.cc-floating{padding:2em;max-width:24em;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner{padding:1em 1.8em;width:100%;-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}.cc-revoke{padding:.5em}.cc-revoke:hover{text-decoration:underline}.cc-header{font-size:18px;font-weight:700}.cc-btn,.cc-close,.cc-link,.cc-revoke{cursor:pointer}.cc-link{opacity:.8;display:inline-block;padding:.2em;text-decoration:underline}.cc-link:hover{opacity:1}.cc-link:active,.cc-link:visited{color:initial}.cc-btn{display:block;padding:.4em .8em;font-size:.9em;font-weight:700;border-width:2px;border-style:solid;text-align:center;white-space:nowrap}.cc-highlight .cc-btn:first-child{background-color:transparent;border-color:transparent}.cc-highlight .cc-btn:first-child:focus,.cc-highlight .cc-btn:first-child:hover{background-color:transparent;text-decoration:underline}.cc-close{display:block;position:absolute;top:.5em;right:.5em;font-size:1.6em;opacity:.9;line-height:.75}.cc-close:focus,.cc-close:hover{opacity:1}.cc-revoke.cc-top{top:0;left:3em;border-bottom-left-radius:.5em;border-bottom-right-radius:.5em}.cc-revoke.cc-bottom{bottom:0;left:3em;border-top-left-radius:.5em;border-top-right-radius:.5em}.cc-revoke.cc-left{left:3em;right:unset}.cc-revoke.cc-right{right:3em;left:unset}.cc-top{top:1em}.cc-left{left:1em}.cc-right{right:1em}.cc-bottom{bottom:1em}.cc-floating>.cc-link{margin-bottom:1em}.cc-floating .cc-message{display:block;margin-bottom:1em}.cc-window.cc-floating .cc-compliance{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto}.cc-window.cc-banner{-webkit-box-align:center;-ms-flex-align:center;align-items:center}.cc-banner.cc-top{left:0;right:0;top:0}.cc-banner.cc-bottom{left:0;right:0;bottom:0}.cc-banner .cc-message{display:block;-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto;max-width:100%;margin-right:1em}.cc-compliance{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-ms-flex-line-pack:justify;align-content:space-between}.cc-floating .cc-compliance>.cc-btn{-webkit-box-flex:1;-ms-flex:1;flex:1}.cc-btn+.cc-btn{margin-left:.5em}@media print{.cc-revoke,.cc-window{display:none}}@media screen and (max-width:900px){.cc-btn{white-space:normal}}@media screen and (max-width:414px) and (orientation:portrait),screen and (max-width:736px) and (orientation:landscape){.cc-window.cc-top{top:0}.cc-window.cc-bottom{bottom:0}.cc-window.cc-banner,.cc-window.cc-floating,.cc-window.cc-left,.cc-window.cc-right{left:0;right:0}.cc-window.cc-banner{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner .cc-compliance{-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto}.cc-window.cc-floating{max-width:none}.cc-window .cc-message{margin-bottom:1em}.cc-window.cc-banner{-webkit-box-align:unset;-ms-flex-align:unset;align-items:unset}.cc-window.cc-banner .cc-message{margin-right:0}}.cc-floating.cc-theme-classic{padding:1.2em;border-radius:5px}.cc-floating.cc-type-info.cc-theme-classic .cc-compliance{text-align:center;display:inline;-webkit-box-flex:0;-ms-flex:none;flex:none}.cc-theme-classic .cc-btn{border-radius:5px}.cc-theme-classic .cc-btn:last-child{min-width:140px}.cc-floating.cc-type-info.cc-theme-classic .cc-btn{display:inline-block}.cc-theme-edgeless.cc-window{padding:0}.cc-floating.cc-theme-edgeless .cc-message{margin:2em;margin-bottom:1.5em}.cc-banner.cc-theme-edgeless .cc-btn{margin:0;padding:.8em 1.8em;height:100%}.cc-banner.cc-theme-edgeless .cc-message{margin-left:1em}.cc-floating.cc-theme-edgeless .cc-btn+.cc-btn{margin-left:0}.cc-btn {border-width: 1px;display: inline;font-weight: normal;}.cc-link {color: inherit;}.cc-link:hover {color: #a6daff;}.cc-revoke {display: none;}.cc-window,.cc-revoke {background: #3b3d3f;border-radius: 8px 8px 0 0;color: #d7d7d9;font: inherit;}.cc-window.cc-banner,.cc-window.cc-floating {padding: 16px;}.cc-window.cc-floating {bottom: 0;min-width: 100%;}.cc-window {padding: 16px;}.cc-window .cc-mobile {display: none;}.cc-window .message-inverse {background: #222326;border-radius: 8px 8px 0 0;}.cc-window .momentum-body {margin: -16px;width: calc(100% + 32px);}.cc-window .momentum-body .cookie-banner-link {white-space: nowrap;}.cc-window .momentum-body .message {padding: 16px 16px 16px 48px;}.cc-window .momentum-body .message .icon {font-size: 24px;left: 16px;top: 16px;}.cc-window .message-buttons {margin-right: 16px;margin-top: 12px;}.cc-window h4 {color: #fff;margin-bottom: 4px;}@media screen and (max-width: 1150px) {.cc-window .cc-desktop {display: none;}.cc-window .cc-mobile {display: block;margin-top: 16px;}.cc-window .message {display: flex;}}.error-section {text-align: center;}.error-section img {margin-top: 70px;margin-bottom: 16px;}.application-question input,.application-additional input,.application-question textarea,.application-additional textarea {border-color: #e2e2e2;}.application-question input:active,.application-additional input:active,.application-question textarea:active,.application-additional textarea:active,.application-question input:focus,.application-additional input:focus,.application-question textarea:focus,.application-additional textarea:focus {border-color: #7f838a;}.application-question select,.application-additional select {background: #e2e2e2;border-color: transparent;}.application-question select:hover,.application-additional select:hover {background: #c0c0c0;}.application-question.custom-question,.application-additional.custom-question {display: grid;}.application-question.custom-question .application-label.multiple-choice,.application-additional.custom-question .application-label.multiple-choice,.application-question.custom-question .application-label.multiple-select,.application-additional.custom-question .application-label.multiple-select,.application-question.custom-question .application-label.textarea,.application-additional.custom-question .application-label.textarea,.application-question.custom-question .application-label.dropdown,.application-additional.custom-question .application-label.dropdown {margin-bottom: 0px;}.application-question.custom-question .application-field,.application-additional.custom-question .application-field {display: inline-block;}.application-question.custom-question .application-field input[type=text],.application-additional.custom-question .application-field input[type=text],.application-question.custom-question .application-field input[type=email],.application-additional.custom-question .application-field input[type=email],.application-question.custom-question .application-field input[type=tel],.application-additional.custom-question .application-field input[type=tel] {margin-top: 0px;}.application-question.custom-question .application-field input[type=radio],.application-additional.custom-question .application-field input[type=radio],.application-question.custom-question .application-field input[type=checkbox],.application-additional.custom-question .application-field input[type=checkbox] {left: 0px;}.application-question.custom-question .application-field .upload-file-overlay,.application-additional.custom-question .application-field .upload-file-overlay {margin-bottom: 17.5px;}.application-question.custom-question .application-field ul label,.application-additional.custom-question .application-field ul label {padding-left: 30px;}.application .application-question,.eeo-survey .application-question {list-style-type: none;padding: 0px 0px;}.application .application-label,.eeo-survey .application-label {font-size: 16px;line-height: 1.4;vertical-align: middle;width: 100%;}.application .application-label .description,.eeo-survey .application-label .description {font-size: 12px;margin-bottom: 0;}.application .application-label label,.eeo-survey .application-label label {position: relative;}.application .application-label.multiple-choice,.eeo-survey .application-label.multiple-choice,.application .application-label.multiple-select,.eeo-survey .application-label.multiple-select,.application .application-label.textarea,.eeo-survey .application-label.textarea {vertical-align: top;}.application .application-label.text,.eeo-survey .application-label.text {vertical-align: bottom;}.application .application-field,.eeo-survey .application-field {position: relative;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.application .application-field input[type=text],.eeo-survey .application-field input[type=text],.application .application-field select,.eeo-survey .application-field select,.application .application-field input[type=email],.eeo-survey .application-field input[type=email],.application .application-field input[type=tel],.eeo-survey .application-field input[type=tel] {display: inline-block;width: 100%;}.application .application-field input[type=text][disabled],.eeo-survey .application-field input[type=text][disabled],.application .application-field select[disabled],.eeo-survey .application-field select[disabled],.application .application-field input[type=email][disabled],.eeo-survey .application-field input[type=email][disabled],.application .application-field input[type=tel][disabled],.eeo-survey .application-field input[type=tel][disabled] {background-color: #e2e2e2;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {cursor: pointer;outline: none;}.application .application-field .icon-caret-down,.eeo-survey .application-field .icon-caret-down {height: 16px;width: 16px;position: absolute;right: 10px;margin-top: -8px;top: 50%;}.application .application-field ul,.eeo-survey .application-field ul {list-style-type: none;}.application .application-field label,.eeo-survey .application-field label {padding-left: 40px;position: relative;cursor: pointer;}.application .application-field label .application-answer-alternative,.eeo-survey .application-field label .application-answer-alternative {color: #83868c;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 20px;height: 20px;border-radius: 10px;position: relative;border: 1px solid #e2e2e2;}.application .application-field input[type=radio]:active,.eeo-survey .application-field input[type=radio]:active {background: #ebecf0;}.application .application-field input[type=radio]:checked::after,.eeo-survey .application-field input[type=radio]:checked::after {position: absolute;content: "";height: 20px;width: 20px;left: 0;top: 0;border-radius: 10px;background-color: #00a1dc;}.application .application-field input[type=radio]:checked + span,.eeo-survey .application-field input[type=radio]:checked + span,.application .application-field input[type=checkbox]:checked + span,.eeo-survey .application-field input[type=checkbox]:checked + span {color: #515357;}.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {width: 20px;height: 20px;border: 1px solid #e2e2e2;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-field input[type=checkbox]:active,.eeo-survey .application-field input[type=checkbox]:active {background: #ebecf0;}.application .application-field input[type=checkbox]:checked::after,.eeo-survey .application-field input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: -10%;height: 40%;width: 90%;border-bottom: 4px solid #00a1dc;border-left: 4px solid #00a1dc;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {position: absolute;left: 10px;top: 2px;}.application .application-field .application-university,.eeo-survey .application-field .application-university {position: relative;}.application .application-field .application-university .select2-container,.eeo-survey .application-field .application-university .select2-container {height: 40px;}.application .application-field .application-university .select2-container .select2-selection,.eeo-survey .application-field .application-university .select2-container .select2-selection {padding: 4px 4px 4px 7px;height: 40px;}.application .application-field .application-university .select2-container .select2-selection:active,.eeo-survey .application-field .application-university .select2-container .select2-selection:active,.application .application-field .application-university .select2-container .select2-selection:focus,.eeo-survey .application-field .application-university .select2-container .select2-selection:focus {outline: none;border: 1px solid #7f838a;}.application .application-field .application-university .select2-container .select2-selection span,.eeo-survey .application-field .application-university .select2-container .select2-selection span {font-size: 16px !important;}.application .application-field .application-university .select2-container .select2-selection__arrow,.eeo-survey .application-field .application-university .select2-container .select2-selection__arrow {top: 7px;}.application .application-field .application-dropdown,.eeo-survey .application-field .application-dropdown {position: relative;}.application .application-field .application-dropdown select,.eeo-survey .application-field .application-dropdown select {text-indent: 0.01px;-o-text-overflow: '';text-overflow: '';padding-right: 40px;}.application .application-field .application-dropdown select::-ms-expand,.eeo-survey .application-field .application-dropdown select::-ms-expand {display: none;}.application .application-field .application-dropdown::after,.eeo-survey .application-field .application-dropdown::after {position: absolute;content: "";right: 15px;top: 26px;height: 15px;width: 15px;border-bottom: 1px solid #7f838a;border-left: 1px solid #7f838a;border-color: #72767d;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);pointer-events: none;}.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay {max-width: 100%;padding-left: 41px;}.application .application-field .upload-file-overlay .icon-paperclip,.eeo-survey .application-field .upload-file-overlay .icon-paperclip {position: absolute;left: 15px;}.application .application-field input[type=file],.eeo-survey .application-field input[type=file] {position: absolute;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);top: 0;left: 0;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {font-size: 16px;line-height: 1.4;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {border-radius: 3px;border-width: 1px;border-style: solid;height: 40px;padding: 4px 4px 4px 15px;-webkit-transition: 1px solid #e3e4e6 150ms, background 150ms;-moz-transition: 1px solid #e3e4e6 150ms, background 150ms;-o-transition: 1px solid #e3e4e6 150ms, background 150ms;-ms-transition: 1px solid #e3e4e6 150ms, background 150ms;transition: 1px solid #e3e4e6 150ms, background 150ms;}.application .application-question input[type=text]:active,.eeo-survey .application-question input[type=text]:active,.application .application-additional input[type=text]:active,.eeo-survey .application-additional input[type=text]:active,.application .application-question input[type=email]:active,.eeo-survey .application-question input[type=email]:active,.application .application-additional input[type=email]:active,.eeo-survey .application-additional input[type=email]:active,.application .application-question input[type=tel]:active,.eeo-survey .application-question input[type=tel]:active,.application .application-additional input[type=tel]:active,.eeo-survey .application-additional input[type=tel]:active,.application .application-question textarea:active,.eeo-survey .application-question textarea:active,.application .application-additional textarea:active,.eeo-survey .application-additional textarea:active,.application .application-question select:active,.eeo-survey .application-question select:active,.application .application-additional select:active,.eeo-survey .application-additional select:active,.application .application-question input[type=text]:focus,.eeo-survey .application-question input[type=text]:focus,.application .application-additional input[type=text]:focus,.eeo-survey .application-additional input[type=text]:focus,.application .application-question input[type=email]:focus,.eeo-survey .application-question input[type=email]:focus,.application .application-additional input[type=email]:focus,.eeo-survey .application-additional input[type=email]:focus,.application .application-question input[type=tel]:focus,.eeo-survey .application-question input[type=tel]:focus,.application .application-additional input[type=tel]:focus,.eeo-survey .application-additional input[type=tel]:focus,.application .application-question textarea:focus,.eeo-survey .application-question textarea:focus,.application .application-additional textarea:focus,.eeo-survey .application-additional textarea:focus,.application .application-question select:focus,.eeo-survey .application-question select:focus,.application .application-additional select:focus,.eeo-survey .application-additional select:focus {outline: none;}.application .application-question input.location-input,.eeo-survey .application-question input.location-input,.application .application-additional input.location-input,.eeo-survey .application-additional input.location-input {margin-bottom: 0;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload,.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {width: 230px;height: 40px;}.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .visible-resume-upload .icon,.eeo-survey .application-question .visible-resume-upload .icon,.application .application-additional .visible-resume-upload .icon,.eeo-survey .application-additional .visible-resume-upload .icon {position: absolute;}.application .application-question .visible-resume-upload .resume-upload-name,.eeo-survey .application-question .visible-resume-upload .resume-upload-name,.application .application-additional .visible-resume-upload .resume-upload-name,.eeo-survey .application-additional .visible-resume-upload .resume-upload-name {vertical-align: middle;display: inline-block;line-height: 40px;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;margin-left: 24px;margin-bottom: 3px;}.application .application-question .resume-upload-filename,.eeo-survey .application-question .resume-upload-filename,.application .application-additional .resume-upload-filename,.eeo-survey .application-additional .resume-upload-filename {margin: 8px 0px;display: inline-block;font-size: 14px;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload {position: absolute;top: 0px;left: 0px;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);cursor: pointer;}.application .application-question input.invisible-resume-upload:hover,.eeo-survey .application-question input.invisible-resume-upload:hover,.application .application-additional input.invisible-resume-upload:hover,.eeo-survey .application-additional input.invisible-resume-upload:hover {border-color: #f00;}.application .application-question .linkedin-auth-button,.eeo-survey .application-question .linkedin-auth-button,.application .application-additional .linkedin-auth-button,.eeo-survey .application-additional .linkedin-auth-button {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .linkedin-auth-button.added,.eeo-survey .application-question .linkedin-auth-button.added,.application .application-additional .linkedin-auth-button.added,.eeo-survey .application-additional .linkedin-auth-button.added {background: #dadbdf;}.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea {padding-top: 10px;resize: vertical;width: 100%;height: 130px;}.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-question .dropdown-container,.eeo-survey .application-question .dropdown-container,.application .application-additional .dropdown-container,.eeo-survey .application-additional .dropdown-container {display: none;z-index: 1;overflow-y: auto;position: absolute;max-height: 200px;font-size: 14px;font-family: Meta;letter-spacing: 1px;}.application .application-question .dropdown-loading-results,.eeo-survey .application-question .dropdown-loading-results,.application .application-additional .dropdown-loading-results,.eeo-survey .application-additional .dropdown-loading-results {display: none;}.application .application-question .dropdown-no-results,.eeo-survey .application-question .dropdown-no-results,.application .application-additional .dropdown-no-results,.eeo-survey .application-additional .dropdown-no-results {display: none;}.application .application-question .dropdown-location:hover,.eeo-survey .application-question .dropdown-location:hover,.application .application-additional .dropdown-location:hover,.eeo-survey .application-additional .dropdown-location:hover,.application .application-question .dropdown-location-active,.eeo-survey .application-question .dropdown-location-active,.application .application-additional .dropdown-location-active,.eeo-survey .application-additional .dropdown-location-active {background-color: #000;}.application .required,.eeo-survey .required {display: inline-block;color: #ff794f;margin-left: 4px;font-size: 9px;padding-bottom: 0px;position: absolute;}.application .error-message,.eeo-survey .error-message {background: #ff794f;color: #fff;border-radius: 3px;padding: 5px 15px;width: 700px;max-width: 100%;}.resume-upload-failure,.resume-upload-working,.resume-upload-success,.linkedin-login-success {display: none;cursor: default;position: absolute;top: 0;left: 260px;}.resume-upload-working {cursor: wait;}.resume-upload-success,.linkedin-login-success {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 1s;-webkit-animation-name: fadein;}.resume-upload-failure {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 4s;-webkit-animation-name: fadeout;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);display: none;}.resume-upload-failure .resume-upload-label {color: #ff9000;font-size: 13px;font-weight: bold;line-height: 1.8;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);width: 250px;}.resume-upload-oversize {position: relative;display: none;}.resume-upload-label,.linkedin-login-label {position: absolute;line-height: 40px;display: inline-block;height: 40px;margin-left: 15px;width: 230px;}.loading-indicator {display: inline-block;opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);border-radius: 40px;-webkit-animation: loading 1.5s infinite linear;-moz-animation: loading 1.5s infinite linear;-o-animation: loading 1.5s infinite linear;-ms-animation: loading 1.5s infinite linear;animation: loading 1.5s infinite linear;border: 6px solid #00a1dc;border-top: 6px solid rgba(0,0,0,0);border-left: 6px solid rgba(0,0,0,0);width: 40px;height: 40px;}.loading-indicator.completed {border-left: 6px solid #515357;border-right: 6px solid #515357;border-top: 6px solid #515357;border-bottom: 6px solid #515357;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;text-align: center;}.loading-indicator .icon-checkmark {vertical-align: middle;}.loading-indicator .icon-checkmark >path {fill: #515357;}.application-form h4 {margin: 40px 0;}.awli-button-container {display: inline-block;overflow: hidden;position: relative;vertical-align: middle;}.awli-button-container .iframe-mask {position: absolute;left: 0;background-color: #f9f9f9;z-index: 1;}.awli-button-container .iframe-mask.disclaimer-mask {top: -50px;width: 243px;height: 40px;}.awli-button-container .iframe-mask.button-mask {pointer-events: none;width: 243px;height: 100%;}.awli-button,.awli-button:active,.awli-button:focus {position: relative;margin-right: 15px;padding-left: 41px;padding-right: 0;width: 243px;background: #0073b1;border-color: #0073b1;color: #fff;z-index: 10;outline: none;}.awli-button.button-masked,.awli-button:active.button-masked,.awli-button:focus.button-masked {pointer-events: none;}.awli-button.button-masked > div,.awli-button:active.button-masked > div,.awli-button:focus.button-masked > div {pointer-events: none;}.awli-button.button-masked > div > *,.awli-button:active.button-masked > div > *,.awli-button:focus.button-masked > div > * {pointer-events: none;}.awli-button.state-loading > .loading,.awli-button:active.state-loading > .loading,.awli-button:focus.state-loading > .loading {display: block;}.awli-button.state-loading > .ready,.awli-button:active.state-loading > .ready,.awli-button:focus.state-loading > .ready {display: none;}.awli-button.state-loading > .completed,.awli-button:active.state-loading > .completed,.awli-button:focus.state-loading > .completed {display: none;}.awli-button.state-ready > .loading,.awli-button:active.state-ready > .loading,.awli-button:focus.state-ready > .loading {display: none;}.awli-button.state-ready > .ready,.awli-button:active.state-ready > .ready,.awli-button:focus.state-ready > .ready {display: block;}.awli-button.state-ready > .completed,.awli-button:active.state-ready > .completed,.awli-button:focus.state-ready > .completed {display: none;}.awli-button.state-completed > .loading,.awli-button:active.state-completed > .loading,.awli-button:focus.state-completed > .loading {display: none;}.awli-button.state-completed > .ready,.awli-button:active.state-completed > .ready,.awli-button:focus.state-completed > .ready {display: none;}.awli-button.state-completed > .completed,.awli-button:active.state-completed > .completed,.awli-button:focus.state-completed > .completed {display: block;}.awli-button .icon-checkmark path:first-child,.awli-button:active .icon-checkmark path:first-child,.awli-button:focus .icon-checkmark path:first-child {fill: #fff;}.awli-button .icon-linkedin .icon-li-background,.awli-button:active .icon-linkedin .icon-li-background,.awli-button:focus .icon-linkedin .icon-li-background {fill: currentColor;}.awli-button .icon-linkedin .icon-li-text,.awli-button:active .icon-linkedin .icon-li-text,.awli-button:focus .icon-linkedin .icon-li-text {fill: #0073b1;}.awli-button:hover,.awli-button:active:hover,.awli-button:focus:hover {background: #006299;border-color: #006299;color: #fff;outline: none;}.awli-button:hover.state-loading,.awli-button:active:hover.state-loading,.awli-button:focus:hover.state-loading,.awli-button:hover.state-completed,.awli-button:active:hover.state-completed,.awli-button:focus:hover.state-completed {background: #006299;border-color: #006299;color: #fff;}.awli-button:hover.state-loading .icon-checkmark path:first-child,.awli-button:active:hover.state-loading .icon-checkmark path:first-child,.awli-button:focus:hover.state-loading .icon-checkmark path:first-child,.awli-button:hover.state-completed .icon-checkmark path:first-child,.awli-button:active:hover.state-completed .icon-checkmark path:first-child,.awli-button:focus:hover.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button.state-loading,.awli-button:active.state-loading,.awli-button:focus.state-loading,.awli-button.state-completed,.awli-button:active.state-completed,.awli-button:focus.state-completed {background: #0073b1;border-color: #0073b1;color: #fff;}.awli-button.state-loading .icon-checkmark path:first-child,.awli-button:active.state-loading .icon-checkmark path:first-child,.awli-button:focus.state-loading .icon-checkmark path:first-child,.awli-button.state-completed .icon-checkmark path:first-child,.awli-button:active.state-completed .icon-checkmark path:first-child,.awli-button:focus.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button-label {line-height: 1.33;display: block;overflow: hidden;text-align: left;}.awli-disclaimer {color: #969799;font-size: 12px;line-height: 14px;display: inline-block;padding: 10px 0;margin: 0;vertical-align: middle;}.awli-disclaimer a,.awli-disclaimer a:active,.awli-disclaimer a:focus {color: #707173;}.awli-disclaimer a:hover {color: #969799;}.IN-Awli-widget,.IN-widget {display: inline-block;position: absolute;z-index: 0;}.IN-Awli-widget.IN-Awli-widget,.IN-widget.IN-Awli-widget {left: 2px;top: -37px;}.IN-Awli-widget.IN-widget,.IN-widget.IN-widget {left: 4px;top: 7px;}.h-captcha-spacing {width: 304px;height: 78px;}.consent-required:not(:has(div)):after,.consent-required > div:last-child:after {color: #ff794f;content: '✱';display: inline-block;margin-left: 4px;font-size: 9px;position: absolute;}.eeo-light-text {color: #555659;}h5.eeo-paragraph-heading {font-weight: bold;margin-top: 17.5px;}h5.eeo-paragraph-heading + p {margin-top: 0;}hr {border: 1px solid #e3e4e6;}.application .eeo-option-text.application-answer-alternative {margin-bottom: 0;}.eeo-option-description {color: #555659;font-size: 12px;}.eeo-three-col-list {-webkit-column-width: 233.33333333333334px;-moz-column-width: 233.33333333333334px;column-width: 233.33333333333334px;}.eeo-three-col-list > li {margin-left: 30px;}.eeo-more-info-button {display: inline-block;margin-left: 10px;vertical-align: middle;}.eeo-more-info-button > .icon-info > path {fill: #969799;}.eeo-more-info-button:hover > .icon-info > path {fill: #555659;}.eeo-expandable-description > li {margin-bottom: 10px;}li.select2-results__option.select2-results__option--highlighted .posting-option .posting-tags {color: #fff;}.posting-option {display: block;}.posting-option .posting-tags {display: block;line-height: 1em;font-size: 0.6em;color: #939393;}.posting-option .posting-tag {padding-right: 3px;}.posting-option .posting-title {text-align: left;}@-moz-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@media screen and (min-width: 800px) {.application .application-label,.eeo-survey .application-label,.application .application-field,.eeo-survey .application-field {display: inline-block;}.application .application-label,.eeo-survey .application-label {width: 210px;}.application .application-label.full-width,.eeo-survey .application-label.full-width {width: 100%;}.application .application-field,.eeo-survey .application-field {margin-left: 15px;width: 489px;}.application .application-field.full-width,.eeo-survey .application-field.full-width {padding-left: 0;width: 100%;}}.list .agency-header {font-size: 30px;}.list .agency-sub-header {color: #808080;}.list .postings-list-logo {max-width: 400px;max-height: 50px;}.list .postings-list-logo,.list .postings-list-title {display: inline-block;position: relative;min-height: 50px;float: left;}.list .postings-list-title {margin: 13px 0px 13px 0px;}.list .postings-list-logo {margin-right: 20px;}.list .filter-by-label {margin-right: 16px;}.list .filter-bar {line-height: 40px;max-width: 100%;}.list .filter-bar > div:last-of-type {margin-right: 0;}.list .filter-button-wrapper-margin-right {margin-right: 16px;}.list .filter-button-wrapper {display: inline-block;max-width: 100%;outline: none;position: relative;}.list .filter-button-wrapper:focus .filter-button {border-color: #0c92f3;}.list .filter-button-wrapper:active .filter-button {border-color: #dcdcdc;}.list .filter-button-wrapper .filter-button {color: #555659;max-width: 100%;overflow: hidden;padding: 5px 15px;padding-right: 41px;position: relative;-o-text-overflow: ellipsis;text-overflow: ellipsis;}.list .filter-button-wrapper .filter-button.has-selected-filter {color: #555659;font-weight: bold;}.list .filter-button-wrapper .filter-button .filter-button-caret {position: absolute;left: auto;left: initial;right: 15px;vertical-align: middle;}.list .filter-button-wrapper .filter-button.filter-button-mlp {padding: 8px 16px;width: 173px;font-size: 12px;text-align: left;}.list .filter-popup {position: absolute;top: 110%;left: -1px;border: 1px solid #dcdcdc;border-radius: 3px;display: none;font-size: 14px;line-height: 1;max-height: 300px;overflow-y: hidden;overflow-y: auto;text-align: left;white-space: nowrap;z-index: 1;}.list .filter-popup::-webkit-scrollbar {width: 10px;}.list .filter-popup::-webkit-scrollbar-track {background-color: #fff;}.list .filter-popup::-webkit-scrollbar-track:hover {background-color: #f9f9f9;}.list .filter-popup::-webkit-scrollbar-thumb {background-color: #d7d7d9;border: 1px solid #fff;}.list .filter-popup::-webkit-scrollbar-thumb:hover {background-color: #b1b1b3;border-color: #f9f9f9;}.list .filter-popup ul {list-style-type: none;}.list .filter-popup > ul {background: #fff;padding: 8px 0;}.list .filter-popup .group-link,.list .filter-popup .category-link {display: block;padding: 8px 32px;position: relative;}.list .filter-popup .group-link:hover,.list .filter-popup .category-link:hover {background: #f9f9f9;}.list .filter-popup .group-link:focus,.list .filter-popup .category-link:focus {background: #f3faff;outline: none;}.list .filter-popup .group-link .selected-filter-checkmark,.list .filter-popup .category-link .selected-filter-checkmark {position: absolute;left: 8px;}.list .filter-popup .group-link .selected-filter-checkmark > path,.list .filter-popup .category-link .selected-filter-checkmark > path {fill: #0c92f3;}.list .filter-popup .group-link {font-size: 16px;font-weight: bold;}.list .filter-popup .group-item {border-top: 1px solid #e3e4e6;padding: 8px 0;}.list .filter-popup .group-item:first-of-type {border-top: none;padding-top: 0;}.list .filter-popup .group-item:last-of-type {padding-bottom: 0;}.list .no-postings-message {margin-top: 80px;text-align: center;}.list .postings-group {margin: 40px 0px;}.list .horizontal-line {margin-left: 0px;}.list .posting {display: inline-block;position: relative;width: 100%;margin: 10px 0;}.list .posting .posting-apply {position: absolute;top: 0px;right: 0px;height: 40px;text-align: right;}.list .posting .posting-apply a {min-width: 100px;}.list .posting .posting-title:hover h5 {color: #579eee;}.list .posting .agency-posting-title h5 {margin-right: 230px;}.list .posting .posting-categories {height: 30px;vertical-align: top;}.list .posting .posting-category {display: inline-block;margin-right: 15px;}.show .section p {white-space: pre-wrap;}.show .posting-header {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;}.show .posting-header .posting-headline .posting-category {display: inline-block;margin-right: 10px;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-top: 10px;}@media screen and (min-width: 650px) {.show .posting-header .posting-headline {display: table-cell;width: 100%;}.show .posting-header .postings-btn-wrapper {display: table-cell;vertical-align: top;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-left: 30px;}}@media screen and (max-width: 649px) {.show .posting-header {text-align: center;padding-bottom: 40px;}}@media screen and (max-width: 480px) {.show .postings-btn {width: 100%;}}@media print {.postings-btn {display: none !important;}}.page-centered.section.last-section-apply {text-align: center;margin-bottom: 80px;}.page-centered.section.last-section-apply .btn {display: inline-block;}.page-centered.section.last-section-apply .template-btn-submit {margin: 17.5px 0px;}</style></head><body class="list header-compact"><div class="page list"><div class="main-header page-full-width section-wrapper"><div class="main-header-content page-centered narrow-section page-full-width"><a href="https://jobs.lever.co/GoToGroup" class="main-header-logo"><img alt="GoTo Group logo" src="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1682066441676.png"></a></div></div></div><div class="content-wrapper list-page"><div class="content"><div class="section-wrapper page-full-width"><div class="section page-centered"><div class="filter-bar"><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?workplaceType=onsite" rel="nofollow">On-site</a></li><li><a class="category-link" href="?workplaceType=hybrid" rel="nofollow">Hybrid</a></li><li><a class="category-link" href="?workplaceType=remote" rel="nofollow">Remote</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?location=Bali" rel="nofollow">Bali</a></li><li><a class="category-link" href="?location=Balikpapan" rel="nofollow">Balikpapan</a></li><li><a class="category-link" href="?location=Bengaluru" rel="nofollow">Bengaluru</a></li><li><a class="category-link" href="?location=Bogor" rel="nofollow">Bogor</a></li><li><a class="category-link" href="?location=Depok" rel="nofollow">Depok</a></li><li><a class="category-link" href="?location=Gurugram" rel="nofollow">Gurugram</a></li><li><a class="category-link" href="?location=Ho%20Chi%20Minh%20City" rel="nofollow">Ho Chi Minh City</a></li><li><a class="category-link" href="?location=Jakarta" rel="nofollow">Jakarta</a></li><li><a class="category-link" href="?location=Makassar" rel="nofollow">Makassar</a></li><li><a class="category-link" href="?location=Semarang" rel="nofollow">Semarang</a></li><li><a class="category-link" href="?location=Singapore" rel="nofollow">Singapore</a></li><li><a class="category-link" href="?location=Tangerang" rel="nofollow">Tangerang</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Team: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Team<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li class="group-item"><a class="group-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li class="group-item" role="group" aria-label="FinTech - AML/CFT"><a class="group-link" href="?department=FinTech%20-%20AML%2FCFT" rel="nofollow">FinTech - AML/CFT</a><ul><li><a class="category-link" href="?department=FinTech%20-%20AML%2FCFT&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - CISO"><a class="group-link" href="?department=FinTech%20-%20CISO" rel="nofollow">FinTech - CISO</a><ul><li><a class="category-link" href="?department=FinTech%20-%20CISO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Compliance"><a class="group-link" href="?department=FinTech%20-%20Compliance" rel="nofollow">FinTech - Compliance</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Compliance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Consumer Lending"><a class="group-link" href="?department=FinTech%20-%20Consumer%20Lending" rel="nofollow">FinTech - Consumer Lending</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=Lending%20Operations" rel="nofollow">Lending Operations</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Consumer Payments"><a class="group-link" href="?department=FinTech%20-%20Consumer%20Payments" rel="nofollow">FinTech - Consumer Payments</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Consumer%20Experience" rel="nofollow">Consumer Experience</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Money%20Management" rel="nofollow">Money Management</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Payment%20Core" rel="nofollow">Payment Core</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Crypto"><a class="group-link" href="?department=FinTech%20-%20Crypto" rel="nofollow">FinTech - Crypto</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Crypto&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Data Products &amp; Infra"><a class="group-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra" rel="nofollow">FinTech - Data Products &amp; Infra</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra&amp;team=OneKYC" rel="nofollow">OneKYC</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Finance"><a class="group-link" href="?department=FinTech%20-%20Finance" rel="nofollow">FinTech - Finance</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Finance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Merchant Services"><a class="group-link" href="?department=FinTech%20-%20Merchant%20Services" rel="nofollow">FinTech - Merchant Services</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Merchant%20Lending" rel="nofollow">Merchant Lending</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Offline%20Merchants" rel="nofollow">Offline Merchants</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Online%20Merchants" rel="nofollow">Online Merchants</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - CIO"><a class="group-link" href="?department=HoldCo%20-%20CIO" rel="nofollow">HoldCo - CIO</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20CIO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - CISO"><a class="group-link" href="?department=HoldCo%20-%20CISO" rel="nofollow">HoldCo - CISO</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20CISO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - COO Office"><a class="group-link" href="?department=HoldCo%20-%20COO%20Office" rel="nofollow">HoldCo - COO Office</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20COO%20Office&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Corporate Affairs"><a class="group-link" href="?department=HoldCo%20-%20Corporate%20Affairs" rel="nofollow">HoldCo - Corporate Affairs</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Corporate%20Affairs&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=HoldCo%20-%20Corporate%20Affairs&amp;team=Media%20Intelligence" rel="nofollow">Media Intelligence</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Enterprise Risk Management"><a class="group-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management" rel="nofollow">HoldCo - Enterprise Risk Management</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - ESG"><a class="group-link" href="?department=HoldCo%20-%20ESG" rel="nofollow">HoldCo - ESG</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20ESG&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Finance"><a class="group-link" href="?department=HoldCo%20-%20Finance" rel="nofollow">HoldCo - Finance</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Finance&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=HoldCo%20-%20Finance&amp;team=Procurement" rel="nofollow">Procurement</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - People &amp; Culture"><a class="group-link" href="?department=HoldCo%20-%20People%20%26%20Culture" rel="nofollow">HoldCo - People &amp; Culture</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20People%20%26%20Culture&amp;team=HR%20Information%20Systems" rel="nofollow">HR Information Systems</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Ads"><a class="group-link" href="?department=ODS%20-%20Ads" rel="nofollow">ODS - Ads</a><ul><li><a class="category-link" href="?department=ODS%20-%20Ads&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Consumer Platform"><a class="group-link" href="?department=ODS%20-%20Consumer%20Platform" rel="nofollow">ODS - Consumer Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Consumer%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Data Platform"><a class="group-link" href="?department=ODS%20-%20Data%20Platform" rel="nofollow">ODS - Data Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Data%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Engineering Platform"><a class="group-link" href="?department=ODS%20-%20Engineering%20Platform" rel="nofollow">ODS - Engineering Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Engineering%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Food"><a class="group-link" href="?department=ODS%20-%20Food" rel="nofollow">ODS - Food</a><ul><li><a class="category-link" href="?department=ODS%20-%20Food&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Groceries"><a class="group-link" href="?department=ODS%20-%20Groceries" rel="nofollow">ODS - Groceries</a><ul><li><a class="category-link" href="?department=ODS%20-%20Groceries&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Logistics"><a class="group-link" href="?department=ODS%20-%20Logistics" rel="nofollow">ODS - Logistics</a><ul><li><a class="category-link" href="?department=ODS%20-%20Logistics&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Marketplace"><a class="group-link" href="?department=ODS%20-%20Marketplace" rel="nofollow">ODS - Marketplace</a><ul><li><a class="category-link" href="?department=ODS%20-%20Marketplace&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Platform Mobility, Care &amp; Comms"><a class="group-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms" rel="nofollow">ODS - Platform Mobility, Care &amp; Comms</a><ul><li><a class="category-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Public Policy &amp; Government Relations"><a class="group-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations" rel="nofollow">ODS - Public Policy &amp; Government Relations</a><ul><li><a class="category-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Regions"><a class="group-link" href="?department=ODS%20-%20Regions" rel="nofollow">ODS - Regions</a><ul><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Central%20West%20Java%20Regions" rel="nofollow">Central West Java Regions</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=East%20Java%2C%20Bali%2C%20Nusra%20Regions" rel="nofollow">East Java, Bali, Nusra Regions</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Emerging%20Market" rel="nofollow">Emerging Market</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Jabodetabek%20Regions" rel="nofollow">Jabodetabek Regions</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Sales"><a class="group-link" href="?department=ODS%20-%20Sales" rel="nofollow">ODS - Sales</a><ul><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=Sales%20Excellence" rel="nofollow">Sales Excellence</a></li><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=Sales%20Strategy" rel="nofollow">Sales Strategy</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Customer Relationship Management"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management" rel="nofollow">ODS - Shared Service, Customer Relationship Management</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Marketing"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing" rel="nofollow">ODS - Shared Service, Marketing</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Technology"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology" rel="nofollow">ODS - Shared Service, Technology</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport"><a class="group-link" href="?department=ODS%20-%20Transport" rel="nofollow">ODS - Transport</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport &amp; Mobility"><a class="group-link" href="?department=ODS%20-%20Transport%20%26%20Mobility" rel="nofollow">ODS - Transport &amp; Mobility</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport%20%26%20Mobility&amp;team=-" rel="nofollow">-</a></li></ul></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Work type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Work type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?commitment=Direct%20Contract" rel="nofollow">Direct Contract</a></li><li><a class="category-link" href="?commitment=Internship" rel="nofollow">Internship</a></li><li><a class="category-link" href="?commitment=Permanent" rel="nofollow">Permanent</a></li><li><a class="category-link" href="?commitment=" rel="nofollow">Uncategorized</a></li></ul></div></div><noscript><style type="text/css">.filter-button-wrapper:focus {outline: none;}.filter-button-wrapper .filter-popup {top: 100%;}.filter-button-wrapper:focus .filter-popup,.filter-button-wrapper:hover .filter-popup,.filter-button-wrapper:active .filter-popup {display: block;}</style></noscript></div><div class="postings-wrapper"><div class="postings-group"><div class="large-category-header">FinTech - AML/CFT</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f8ec8194-1eb5-4bdb-8419-a57a4966b1c5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5"><h5 data-qa="posting-name">Merchants AML/CFT Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - CISO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="36caef5f-7a1c-4326-80b4-8c146060ac70"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70"><h5 data-qa="posting-name">IT GRC Senior Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Compliance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a9daeacc-5dda-4735-ad7b-db35eb7593a6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6"><h5 data-qa="posting-name">FinServ Compliance Officer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="90d1d8b9-75fb-4211-8d69-99412932f5ba"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba"><h5 data-qa="posting-name">Payments Compliance PPGR Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Consumer Lending</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a3543985-6d2c-45cf-84f7-312ec7efed36"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36"><h5 data-qa="posting-name">Full Stack Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9bc8bd8a-cadc-4942-81c4-193773a294df"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df"><h5 data-qa="posting-name">Growth Analyst - GoPay Later</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6dc20c4e-4d40-4f57-a138-4776013e454e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e"><h5 data-qa="posting-name">Head of Operation - Consumer Lending - #10162</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c9452ba2-cbb3-4ea5-83f7-79e765a67e58"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58"><h5 data-qa="posting-name">Lead Internal Auditor</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0"><h5 data-qa="posting-name">Lead MLOps Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="44117b68-3ece-40ac-91c1-920caadfe5dd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd"><h5 data-qa="posting-name">Principal Data Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="92f4b266-849a-42f2-b7e0-859360a003d8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8"><h5 data-qa="posting-name">Program Manager, Consumer Lending - #10310</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="5611e062-e094-4da3-ab1c-75c85cf62194"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194"><h5 data-qa="posting-name">Risk Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><h5 data-qa="posting-name">Senior Data Analyst (Analytics Engineer)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="472ae629-87cb-4f8c-bb69-eae35cf3751e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e"><h5 data-qa="posting-name">Senior SDET - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d3b7122b-692b-4815-8aa9-f1d0259bccd5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5"><h5 data-qa="posting-name">Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><h5 data-qa="posting-name">Senior Software Engineer (Backend) - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><h5 data-qa="posting-name">Site Reliability Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="88358de8-e37b-4bd6-9afe-359eea3128b9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9"><h5 data-qa="posting-name">Software Engineer (Full Stack) - BNPL</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="afb5bc40-aa4f-4837-a2d9-7d38eade2599"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599"><h5 data-qa="posting-name">Strategy Senior Manager, Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="17408b81-f5a0-4f15-afae-cc04ed7e43b6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6"><h5 data-qa="posting-name">Underwriting and Credit Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Lending Operations</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="0ae5053b-3c5f-432a-9b69-b4cdefb01b79"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79"><h5 data-qa="posting-name">Operation Business Intelligence Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Consumer Payments</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="325ee617-30f3-41c1-a022-6577bd82faf0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0"><h5 data-qa="posting-name">Business Analyst - GoPay</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9a8977f6-ea32-40e0-bb09-d3330c40d056"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056"><h5 data-qa="posting-name">Business Operations Analyst (Trust and Safety) - GoPay - #10311</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da1197ac-dfbc-4ad6-b215-2f2cd4939a0d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d"><h5 data-qa="posting-name">Junior UX Writer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="153e42ca-cf5b-4f43-b09e-58eabda1e5fa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa"><h5 data-qa="posting-name">Senior SDET - Consumer Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Consumer Experience</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="5f86f9c4-80bc-437f-b09c-b61fd85c27eb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb"><h5 data-qa="posting-name">Growth Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="0169bd4d-f352-4162-8e8e-2c09df5b8db4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4"><h5 data-qa="posting-name">SDET - Growth</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Money Management</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8906c3d0-c77f-4a0a-8f25-8b738515ede3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3"><h5 data-qa="posting-name">QA Engineer - Insurance</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bf41d2c6-91b0-4c83-a145-dfcb3ee24b62"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62"><h5 data-qa="posting-name">Savings Growth Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="389c0346-14e0-40e5-85c3-48d830db73b4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4"><h5 data-qa="posting-name">Senior Software Engineer (iOS) - Money Management</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="75c0d634-b28a-4f10-8f5a-efacb32b6444"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444"><h5 data-qa="posting-name">Sr. Software Engineer (Android) - Insurance</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Payment Core</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="78d59624-b02e-4370-b23b-25677dfb1b20"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20"><h5 data-qa="posting-name">Senior SDET - Consumer Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="076bd021-0157-42a4-89fd-51d9f236e490"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490"><h5 data-qa="posting-name">Senior SDET - Payment Widget &amp; Vendor Gateway</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="96562e50-0bf7-4a14-a910-4ef63f16d451"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451"><h5 data-qa="posting-name">Software Engineer - Android (Consumer Payments)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4439eb62-6f08-444b-946d-1dff07d7d0d3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3"><h5 data-qa="posting-name">Software Engineer - iOS ( Consumer Payments)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Crypto</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="08aa1472-d91f-4c5d-b5e0-e88163943bcd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd"><h5 data-qa="posting-name">Security and System Infra Manager (CISSP) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="fda395d6-457d-4a03-aaa1-33d513c3960b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b"><h5 data-qa="posting-name">Senior Software Engineer (Android) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="769b7391-e6fd-4923-9a92-e060f14e451d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d"><h5 data-qa="posting-name">Senior Software Engineer (Back End) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bcd00ee0-2fb3-43c1-8401-ef184283ccc8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8"><h5 data-qa="posting-name">Senior Software Engineer (Front End) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e6c36118-5d4e-444b-922c-68e03c2ab82e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e"><h5 data-qa="posting-name">Senior Software Engineer (iOS) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Data Products &amp; Infra</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="816f2d4c-5ff6-4e83-8697-9c25df599409"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409"><h5 data-qa="posting-name">Data Scientist Intern</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="0197001e-f39c-4d55-b6b9-1cf247bd17b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0"><h5 data-qa="posting-name">Principal Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="60d37414-287e-4552-a0d0-accf1737d0ce"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce"><h5 data-qa="posting-name">Risk Analyst - Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a61cda6c-82fd-4daf-aabf-3db91e01684f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f"><h5 data-qa="posting-name">Risk Manager - Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><h5 data-qa="posting-name">Senior Data Engineer - Data Streaming</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="a539cdc1-109f-48e8-9b24-1a831b735f01"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01"><h5 data-qa="posting-name">Senior Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="10dbc666-80f8-4250-85ee-59fa92d056aa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa"><h5 data-qa="posting-name">Senior Software Engineer (Data Warehouse)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="449dd201-2d4d-47a0-9cd4-c7ddec91c88e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e"><h5 data-qa="posting-name">Senior Software Engineer (Real-Time Data Streaming)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">OneKYC</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="c98e554f-20cd-4d37-80b7-46794ef7bedb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb"><h5 data-qa="posting-name">Ops and Project Manager - OneKYC</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="22a1f73e-1fed-464e-a66c-72139d289c14"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14"><h5 data-qa="posting-name">Project Manager - OneKYC</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="60283bc5-9f60-400a-8289-bcbe332fbc09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09"><h5 data-qa="posting-name">Financial Controller Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Merchant Services</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="761415aa-89b7-4ffb-a19b-2b91ac4243b4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4"><h5 data-qa="posting-name">Growth Lead (Merchant Lending)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="70493d8a-7d7f-4660-b1ed-c792d0d765be"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be"><h5 data-qa="posting-name">Head of Sales - Midtrans - #9618</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="3f4f687f-8599-4d5c-96d5-8af234c3b09d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d"><h5 data-qa="posting-name">Onboarding &amp; Support Business Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="fc7c3413-6c4f-42bd-a048-70387bd490a4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4"><h5 data-qa="posting-name">Process Improvement Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><h5 data-qa="posting-name">Sales Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Merchant Lending</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="dab778da-b4eb-4e7e-bc8e-997af7210d52"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52"><h5 data-qa="posting-name">Software Engineer (Back End) - Merchant Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Offline Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ad8bd932-3494-4181-bd93-282665dce81d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d"><h5 data-qa="posting-name">Learning &amp; Development Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><h5 data-qa="posting-name">Product Design Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="50c8a826-2076-40a3-a829-b96b29c9647f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f"><h5 data-qa="posting-name">Senior Product Marketing Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Online Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="83c662d2-4a1e-40ca-a2d3-daf2a1b102b8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8"><h5 data-qa="posting-name">Product Analyst Intern - Online Merchants</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="afd9e752-82f0-4b4f-a4ef-5d86dcce1063"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063"><h5 data-qa="posting-name">Senior Sales Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1a190954-9482-4953-a750-f2ae33a50003"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003"><h5 data-qa="posting-name">Software Engineer Intern - Online Merchants</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - CIO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4cb00240-117e-4ace-a959-fc567e447d5f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f"><h5 data-qa="posting-name">IT Finance Project Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="099498bc-c171-4505-97d7-3a432d302e14"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14"><h5 data-qa="posting-name">Senior SAP Technical</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - CISO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="178ba514-705f-4f0b-9e48-fe917c47a95b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b"><h5 data-qa="posting-name">Enterprise Information Security Engineer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9a7a6e83-9532-48a6-b1b1-b7a1350b4f12"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12"><h5 data-qa="posting-name">Security Engineering Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="767d8980-5402-488d-b62c-222c0b4a0bfc"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc"><h5 data-qa="posting-name">Senior Cyber Threat Intelligence Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - COO Office</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="2242125a-7155-4353-bc79-473d237d6808"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808"><h5 data-qa="posting-name">Business Intelligence Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="73e71b86-d53f-4841-92ec-4bd09a0ef479"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479"><h5 data-qa="posting-name">Data Engineer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="36d71dff-c9ac-44b8-b870-f74d941bd7d3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3"><h5 data-qa="posting-name">Data Engineer Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6d8ebb73-2348-423d-847e-b8a8408ac1ed"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed"><h5 data-qa="posting-name">Senior Data Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Corporate Affairs</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="fc5f2c90-038e-4c53-9971-2ae72f680c03"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03"><h5 data-qa="posting-name">International &amp; Singapore Communications Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Media Intelligence</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a3de3e96-fc51-46e4-bcd4-f012f0d03bdb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb"><h5 data-qa="posting-name">Media Intelligence Intern</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Enterprise Risk Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><h5 data-qa="posting-name">Head of Business Continuity Management</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9c0a73a5-09ce-4b06-8527-9415ef3d393c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c"><h5 data-qa="posting-name">Internal Audit Senior Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - ESG</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="1a303596-73f9-4d05-85f9-73cd361f03ef"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef"><h5 data-qa="posting-name">Sustainability Senior Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="56966262-038f-497f-84c1-f360a9440c55"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55"><h5 data-qa="posting-name">Assistant Tax Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Procurement</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274"><h5 data-qa="posting-name">Procurement Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - People &amp; Culture</div><div class="posting-category-title large-category-label">HR Information Systems</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8fe35112-8410-4cf3-9a50-4c7287e95b57"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57"><h5 data-qa="posting-name">People Systems Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta / Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Ads</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="94f85d13-6fe6-43a8-96c8-4898ab75d908"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908"><h5 data-qa="posting-name">Ads Ops Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="eaab5bee-084d-4cdc-bd08-63230251009c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c"><h5 data-qa="posting-name">Supply Strategy Data Analyst [Ads]</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Consumer Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ab96f280-f1d6-4ff7-bbe8-198ee4168bb4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4"><h5 data-qa="posting-name">Market Intelligence (Data Engineer)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="976d0171-5a06-43e2-9ec6-e0b45345c6fd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd"><h5 data-qa="posting-name">Senior Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="86673189-b5e2-4ace-b1a3-5ab20f14d84d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d"><h5 data-qa="posting-name">Senior Data Scientist (India)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="cd554abc-dc06-4177-be50-ccbc638fd6d9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9"><h5 data-qa="posting-name">Software Engineer - Customer Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Data Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="e6583aa0-7097-4e6f-9f91-7f24d5441156"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156"><h5 data-qa="posting-name">Senior Product Manager, Data Science Platform and Data Products</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta / Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="d8170197-90ca-4f87-a48d-d1a3175538ce"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce"><h5 data-qa="posting-name">Senior Software Engineer - Data Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Engineering Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="dfe98505-36d8-4467-aa36-df8599ab69d8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8"><h5 data-qa="posting-name">Engineering Manager - Data Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="f7107250-7aa4-487c-8821-8948dfb0fbc3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3"><h5 data-qa="posting-name">Frontend Engineer - Web Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><h5 data-qa="posting-name">Fullstack Engineer - Engineering Platforms</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a593bf17-baf2-479e-8154-c69d6a7d4f09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09"><h5 data-qa="posting-name">Lead Software Engineer - Engineering Platforms</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><h5 data-qa="posting-name">Lead Software Engineer - Observability</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="6f2d563a-182c-4c23-8c72-9d2a4f563ed9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9"><h5 data-qa="posting-name">Principal Engineer - Cloud Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru / Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="7c3c43e3-8b8d-48a4-a590-7754207b2d1b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b"><h5 data-qa="posting-name">Principal Software Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><h5 data-qa="posting-name">Senior Data Warehouse Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2b430ba4-210e-4db6-a63e-c11459a0304f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f"><h5 data-qa="posting-name">Senior Data Warehouse Engineer - India</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><h5 data-qa="posting-name">Senior Database Administrator Engineer - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="28fe323b-ed5f-482b-b71d-ed60662bed8b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b"><h5 data-qa="posting-name">Senior DevOps Engineer - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="68f907a3-329f-411b-af2d-a66b38243919"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919"><h5 data-qa="posting-name">Senior Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8afd4278-a5a8-43f2-8718-2986433f2ddb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb"><h5 data-qa="posting-name">Senior Technical Program Manager - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><h5 data-qa="posting-name">Software Engineer - Android</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3"><h5 data-qa="posting-name">Technical Program Manager - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Food</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="657d7112-420a-4e42-8bfd-1b790fc05155"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155"><h5 data-qa="posting-name">#10357 Senior Software Engineer - Go-food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><h5 data-qa="posting-name">Growth Planning &amp; Operation - GoFood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><h5 data-qa="posting-name">Growth Strategy Manager - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2d3aae20-ff7e-4afb-8164-a351661c1680"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680"><h5 data-qa="posting-name">Lead Software Engineer (IC) - Go-Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="e407433b-435a-4607-89bd-5faf51cf622e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e"><h5 data-qa="posting-name">Product Designer - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><h5 data-qa="posting-name">Product Manager - Growth</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da8d4a37-f5a4-4436-8743-58c787781285"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285"><h5 data-qa="posting-name">Senior Growth Manager - Food &amp; Ads</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="57bb5e7f-9ea0-462f-ac36-5717b49d0380"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380"><h5 data-qa="posting-name">Senior Software Engineer - Go-food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="930cfb6b-99e3-4334-bc10-3fac18f8eff0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0"><h5 data-qa="posting-name">Software Engineer (Android) - Gofood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Groceries</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="87b4d0e4-219e-4ba7-9433-27220623ab69"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69"><h5 data-qa="posting-name">#10358 Software Engineer - Backend (Groceries)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="03e3c5dd-2c14-4737-820e-f32b6cccf632"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632"><h5 data-qa="posting-name">Operations Manager - GoMart</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="49388333-1938-4c06-b453-911eee08c53f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f"><h5 data-qa="posting-name">Pricing &amp; Supply Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663"><h5 data-qa="posting-name">User Growth Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Logistics</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f53cae40-f605-4215-9a82-b48c5db508b5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5"><h5 data-qa="posting-name">#10010 Senior Backend Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="ce351965-e2f9-4f8f-8cad-38fb4cd045e9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9"><h5 data-qa="posting-name">#10279 Senior Android Developer (Logistic)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958"><h5 data-qa="posting-name">#10359 Software Engineer - Backend</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="180b3e9e-cfb9-471d-8c30-410aef031535"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535"><h5 data-qa="posting-name">Software Engineer  - Logistic</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Marketplace</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8d7ae844-168c-4e78-843a-94aceb7b1a66"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66"><h5 data-qa="posting-name">Senior Software Engineer  - Marketplace</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Platform Mobility, Care &amp; Comms</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><h5 data-qa="posting-name">Product Manager - Logistic</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="34f6146a-c482-407c-a31c-72ac9bb90a7c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c"><h5 data-qa="posting-name">Senior Data Scientist - Marketplace (Singapore)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Public Policy &amp; Government Relations</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><h5 data-qa="posting-name">Manager of Food &amp; Groceries Regulatory</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bf9ad9be-9cca-41e0-9c6d-a6b66e91726b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b"><h5 data-qa="posting-name">Transport and Mobility PPGR Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Regions</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb"><h5 data-qa="posting-name">Area Operations Manager - Bekasi</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><h5 data-qa="posting-name">Area Operations Manager (Bogor Depok)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Depok / Bogor</span></div></a></div><div class="posting" data-qa-posting-id="8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><h5 data-qa="posting-name">Area Operations Staff</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="719f7a78-460a-4496-9298-ca57b835b120"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120"><h5 data-qa="posting-name">Operation Support Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4ba1eea8-feed-4843-be2e-93a21f0eadb1"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1"><h5 data-qa="posting-name">Region Analytics Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div><div class="posting" data-qa-posting-id="3377f50a-d56f-42e0-acc5-b69d405a37a9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9"><h5 data-qa="posting-name">Senior/Partnership Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Central West Java Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f1bdce17-4ab5-49ab-9dbc-6d96a5619846"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846"><h5 data-qa="posting-name">Area CE Associate - Semarang - #10227</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Semarang</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">East Java, Bali, Nusra Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="73172a46-5486-4860-a256-8e17225c4a47"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47"><h5 data-qa="posting-name">Account Executive (Bali)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Bali</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Emerging Market</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="95ee9a06-a46d-43a2-a8e7-003de776404d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d"><h5 data-qa="posting-name">Area Operations Supervisor - Balikpapan</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Balikpapan</span></div></a></div><div class="posting" data-qa-posting-id="20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450"><h5 data-qa="posting-name">Area Sales Support Supervisor (Sulampa)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Makassar</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Jabodetabek Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="94efd0c8-e79b-41e1-aa37-a7a4c08c108f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f"><h5 data-qa="posting-name">Account Executive (Tangerang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="885b2af9-c94a-4010-b0c4-c6ea7812039b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b"><h5 data-qa="posting-name">Account Executive (Tangerang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Sales</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a007af4b-690d-4487-874d-f04ce3f62ce0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0"><h5 data-qa="posting-name">Unmanaged Merchant Engagement Senior Associate - #10326</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Sales Excellence</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f39be622-e287-41df-bcb2-7389478a1be4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4"><h5 data-qa="posting-name">Sales Support Senior Associate, Enterprise</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Sales Strategy</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6"><h5 data-qa="posting-name">Head of Sales Strategy - #10056</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Customer Relationship Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="0489939a-c571-4d5f-adaa-95ceac8912c5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5"><h5 data-qa="posting-name">Region Operations Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><h5 data-qa="posting-name">Strategic Planner - Creative Labs - #10088</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Marketing</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="7d1c915f-ac53-4a2c-887a-41bbbda48a26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26"><h5 data-qa="posting-name">Graphic Designer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><h5 data-qa="posting-name">Social Media Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Technology</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4a126665-42d6-4a36-82a5-089dca789f41"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41"><h5 data-qa="posting-name">Lead Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="426f18b4-739e-4da0-a74b-446c349c0a31"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31"><h5 data-qa="posting-name">Principal Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="376aefd9-6d6c-4e57-8040-a3b0dd416d26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><h5 data-qa="posting-name">Senior SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="331177df-4294-4bc1-93a4-6459ff18ef97"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97"><h5 data-qa="posting-name">Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e2bbb29c-85ef-4db2-9ea7-93af9101b634"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634"><h5 data-qa="posting-name">Sr. Software Engineer (iOS) - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru / Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="d93a7524-8ab9-4499-9f04-0876fcafa529"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529"><h5 data-qa="posting-name">Data Operations Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="5d07cd21-8826-4de7-9ad4-15909a0c5c37"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37"><h5 data-qa="posting-name">Digital Marketing Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="eb38692a-8133-4cd2-a793-f5d75ee8841a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a"><h5 data-qa="posting-name">Driver Care Lead, Hub Operations</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="c48698b4-3bff-4e56-b250-cadf67700c6d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d"><h5 data-qa="posting-name">Fleet Account Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c838dc08-24e8-417c-9d70-a617bc58e200"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200"><h5 data-qa="posting-name">Head of Engineering - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="f1d481f6-4e2d-401b-b310-fca641ab29d4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4"><h5 data-qa="posting-name">Lead - iOS (Transport)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="9e0d8fd7-d416-49ee-8c0a-fcad22c923b7"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7"><h5 data-qa="posting-name">Lead Software Engineer - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="967cfe0a-0243-4a2d-8813-038c355e43c3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3"><h5 data-qa="posting-name">Marketing Planning Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6f3368c9-6e84-489c-add3-4ad1fd4b9519"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519"><h5 data-qa="posting-name">Operations Analyst, Data Operations (Trust &amp; Safety)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="0911a6fe-475a-498f-bf48-7d492e3d04d2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2"><h5 data-qa="posting-name">Pricing &amp; Supply Senior Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="20554643-fae8-4082-8797-7d5fd44db8b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0"><h5 data-qa="posting-name">Project Manager - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><h5 data-qa="posting-name">Risk Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="53c0b8a9-1a83-4c34-9a59-b5170ce54193"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193"><h5 data-qa="posting-name">Senior Software Engineer - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c0e92e19-ce60-4cfc-a58b-553f17452483"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483"><h5 data-qa="posting-name">Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="89a62415-b145-4593-ac20-b82ec0ccfacb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb"><h5 data-qa="posting-name">Software Engineer (iOS) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="22ac4805-bcbe-4698-9e51-cb25754ac244"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244"><h5 data-qa="posting-name">Sr. Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport &amp; Mobility</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8bf17375-6318-400f-8216-4a132071777a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a"><h5 data-qa="posting-name">Lead Product Manager, GoCorp</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div></div></div></div></div></div><div class="main-footer page-full-width"><div class="main-footer-text page-centered"><p><a href="https://www.gotocompany.com/">GoTo Group Home Page</a></p><a href="https://www.lever.co/job-seeker-support/" class="image-link"><span>Jobs powered by </span><img alt="Lever logo" src="/img/lever-logo-full.svg"></a></div></div><script src="/js/bug-snag.js" data-apikey="6a247c6ff13012d02fde17377f0b857b" data-appversion="0.0.1721278246" data-endpoint="https://bugs.lever.co/js" data-releasestage="production"></script><script>var gaCode = "UA-129682534-1";</script><script>var gaAllowLinker = false;</script><script async src="https://www.googletagmanager.com/gtag/js?id=UA-129682534-1"></script><script>if (gaCode.startsWith('UA')) {window.initializeGoogleAnalytics = function() {(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,'script','//www.google-analytics.com/analytics.js','ga');ga('create', gaCode, {name: "customer",allowLinker: gaAllowLinker,});ga('customer.send', 'pageview');}} else {window.initializeGoogleAnalytics = function() {window.dataLayer = window.dataLayer || [];function gtag(){dataLayer.push(arguments);}gtag('js', new Date());gtag('config', gaCode);if (gaAllowLinker) {gtag('set', 'linker', 'lever.co');}}}</script><script type="text/javascript">/*We only want to not initialize Google Analytics and Segment on load if the following is true:- `gdpr` is enabled for the account- the account has the `cookieBanner` enabled- the account has the `optIn` cookieBanner typeThis is the only case where an applicant has to explicitly opt-in to the cookie consent before we can load GA/Segment*//* 2022-03-08: Disabling segment tracking due to an explosion in MAU after removing identify call */window.initializeGoogleAnalytics();window.hasInitializedAnalytics = true;</script></body></html><script src="/js/jquery-3.6.1.min.js"></script><script src="/js/list.js"></script>
+  recorded_at: Tue, 30 Jul 2024 16:27:53 GMT
 - request:
     method: get
     uri: https://api.lever.co/v0/postings/GoToGroup/?mode=json
@@ -62,11 +62,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:12 GMT
+      - Tue, 30 Jul 2024 16:27:55 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
-      - '1293098'
+      - '1477609'
       Connection:
       - keep-alive
       Strict-Transport-Security:
@@ -76,17 +76,17 @@ http_interactions:
       X-Xss-Protection:
       - 1; mode=block
       Etag:
-      - W/"13bb2a-ND4sIG4iS6GHXzSA1V2lV+Aix64"
+      - W/"168be9-PtUkFuKXj/26omgKM7XfE6VxSmE"
       X-Stream-Path:
       - dapi
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        [{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.\n","additional":"<div><b><span style=\"font-size: 16px\">About The Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Account Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</span></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Malang","team":"-","allLocations":["Malang"]},"createdAt":1718804353678,"descriptionPlain":"About The Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><span style=\"font-size: 16px\">About The Role</span></div><div><br></div><div><span style=\"font-size: 16px\">Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</span></div>","id":"4df84464-9b48-4256-b23d-021d9d7cd376","lists":[{"text":"What You Will Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix, sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regularly review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transaction</li><li>Create regular report to what's happen in their respective areas toward Regional/Nation-Wide company strategy</li>"},{"text":"What You Will Need","content":"<li>2 years relevant experience with preferable industries: top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region </li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Malang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">About The Role</span></div><div><br></div><div><span style=\"font-size: 16px;\">Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</span></div>","descriptionBodyPlain":"About The Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4df84464-9b48-4256-b23d-021d9d7cd376","applyUrl":"https://jobs.lever.co/GoToGroup/4df84464-9b48-4256-b23d-021d9d7cd376/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717062265203,"descriptionPlain":"About The Role\n\nAccount Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Account Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.</span></div>","id":"9d5d858b-0e72-41c4-8acf-fed0f7f1cf0b","lists":[{"text":"What You Will Do:","content":"<li>Create sales &amp; journey plan to achieve the assigned target in areas like product mix, sales volume, market shares for his/her territory</li><li>Engage merchants within his/her territory to keep them active in Gojek ecosystem &amp; to increase revenue for the company</li><li>Provide advice &amp; offer solution to the merchants in his/her territory based on data so that the merchants can grow&nbsp;</li><li>Create regular reports on what's happening in his/her respective territory and his/her team’s territory</li><li>Know when to escalate &amp; ask help from DSM for bigger issues</li><li>Any other assigned task related to Sales motion</li><li>Handling objection dan complain handling</li>"},{"text":"What You Will Need:","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"},{"text":"About The Team","content":"<li>Account Manager (AM) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support team. Ideally, an AM regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</li>"}],"text":"Account Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Account Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.</span></div>","descriptionBodyPlain":"About The Role\n\nAccount Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9d5d858b-0e72-41c4-8acf-fed0f7f1cf0b","applyUrl":"https://jobs.lever.co/GoToGroup/9d5d858b-0e72-41c4-8acf-fed0f7f1cf0b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Tangerang","team":"-","allLocations":["Tangerang"]},"createdAt":1712309314064,"description":"","descriptionPlain":"","id":"8c43d5dc-1ee7-4fa1-9a41-366eea4b4caa","lists":[],"text":"Account Manager - Tangerang","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/8c43d5dc-1ee7-4fa1-9a41-366eea4b4caa","applyUrl":"https://jobs.lever.co/GoToGroup/8c43d5dc-1ee7-4fa1-9a41-366eea4b4caa/apply"},{"additionalPlain":"Account Manager (AM) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support team. Ideally, an AM regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">Account Manager (AM) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support team. Ideally, an AM regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715157639446,"descriptionPlain":"Account Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.\n","description":"<div><span style=\"font-size: 9pt\">Account Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.</span></div>","id":"dfa07479-8e81-43ff-a9ad-4ae02f72207e","lists":[{"text":"What you will do","content":"<li>Create sales &amp; journey plan to achieve his/her own target in areas like product mix, sales volume, market shares for his/her territory</li><li>Engage merchants within his/her territory to keep them active in Gojek ecosystem &amp; to increase revenue for the company</li><li>Provide advice &amp; offer solution to the merchants in his/her territory based on data so that the merchants can grow&nbsp;</li><li>Create regular reports on what's happening in his/her respective territory and his/her team’s territory</li><li>Know when to escalate &amp; ask help from DSM for bigger issues</li><li>Any other assigned task related to Sales motion</li><li>Handling objection and complain handling</li><div><br></div>"},{"text":"What you will need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li><div><br></div>"}],"text":"Account Manager (North East Jakarta)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Account Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.</span></div>","descriptionBodyPlain":"Account Manager will manage a smaller number of higher-revenue higher-growth SMB merchants. In some districts, AM may be managing AEs. Main responsibility is to ensure that the merchants keep growing in order to achieve the target.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dfa07479-8e81-43ff-a9ad-4ae02f72207e","applyUrl":"https://jobs.lever.co/GoToGroup/dfa07479-8e81-43ff-a9ad-4ae02f72207e/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Finance","location":"Jakarta","team":"Accounting","allLocations":["Jakarta"]},"createdAt":1715077881489,"descriptionPlain":"As our Accountant, you’ll be an instrumental cog in the Accounting team wheel of Gojek that directly impacts the company’s financial reporting process. Collaborating with the other finance streams (FP&A, tax, finance operations, treasury and procurement) as well as business, product and other corporate functions, your main objective will be to ensure any transaction under your scope is properly recorded in the financial statements. You will have ample opportunity to flex your technical accounting and analytical skills, and dive deep into projects surrounding the financial reporting process, collectively getting us even closer to producing reliable and accurate financial statements of the company in a timely manner.\n","description":"<div>As our Accountant, you’ll be an instrumental cog in the Accounting team wheel of Gojek that directly impacts the company’s financial reporting process. Collaborating with the other finance streams (FP&amp;A, tax, finance operations, treasury and procurement) as well as business, product and other corporate functions, your main objective will be to ensure any transaction under your scope is properly recorded in the financial statements. You will have ample opportunity to flex your technical accounting and analytical skills, and dive deep into projects surrounding the financial reporting process, collectively getting us even closer to producing reliable and accurate financial statements of the company in a timely manner.</div>","id":"9aa5a060-e2c3-4296-9057-049a3c1fa5bd","lists":[{"text":"What You Will Do","content":"<li>Ensure accounting process are properly designed and executed and initiate process improvement when necessary</li><li>Identify, analyze and resolve low complexity accounting issues independently</li><li>Review accounting numbers and ensure posted journal entries are complete, accurate and reconciled to the source of data and/or underlying documents</li><li>Review detailed list of financial statements items and ensure they are tallied with trial balance</li><li>Perform and review financial closing activities</li><li>Involve in preparation of statutory financial statements</li>"},{"text":"What You Will Need","content":"<li>A bachelor's or associate’s degree in Accountancy or equivalent</li><li>At least 2 years of experience as auditor in public accounting firm and/or accountant in e-commerce, fintech, technology or other relevant industry</li><li>Strong knowledge of Indonesian Accounting Standards (PSAK), knowledge in International Financial Reporting Standards (IFRS) would be an advantage</li><li>Fluent in English (verbal and written)&nbsp;</li><li>Strong interpersonal communication skills</li><li>Strong attention to detail and accuracy</li><li>Strong problem-solving and analytical mindset</li>"}],"text":"Accountant","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As our Accountant, you’ll be an instrumental cog in the Accounting team wheel of Gojek that directly impacts the company’s financial reporting process. Collaborating with the other finance streams (FP&amp;A, tax, finance operations, treasury and procurement) as well as business, product and other corporate functions, your main objective will be to ensure any transaction under your scope is properly recorded in the financial statements. You will have ample opportunity to flex your technical accounting and analytical skills, and dive deep into projects surrounding the financial reporting process, collectively getting us even closer to producing reliable and accurate financial statements of the company in a timely manner.</div>","descriptionBodyPlain":"As our Accountant, you’ll be an instrumental cog in the Accounting team wheel of Gojek that directly impacts the company’s financial reporting process. Collaborating with the other finance streams (FP&A, tax, finance operations, treasury and procurement) as well as business, product and other corporate functions, your main objective will be to ensure any transaction under your scope is properly recorded in the financial statements. You will have ample opportunity to flex your technical accounting and analytical skills, and dive deep into projects surrounding the financial reporting process, collectively getting us even closer to producing reliable and accurate financial statements of the company in a timely manner.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9aa5a060-e2c3-4296-9057-049a3c1fa5bd","applyUrl":"https://jobs.lever.co/GoToGroup/9aa5a060-e2c3-4296-9057-049a3c1fa5bd/apply"},{"additionalPlain":"About the Team \n\nThe management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.\n\nThe AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 10pt\">About the Team </b></div><div><br></div><div>The management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.</div><div><br></div><div>The AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Legal","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1699323667395,"descriptionPlain":"About the Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at MAB (PT Multifinance Anak Bangsa).Head of AML CFT is responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity she will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).Finally, as a member of the Compliance AML CFT Team, will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Manager must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at MAB (PT Multifinance Anak Bangsa).Head of AML CFT is responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity she will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).Finally, as a member of the Compliance AML CFT Team, will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Manager must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</span></div>","id":"365ef8c5-c4b7-4aab-9d0d-eabea5ef448b","lists":[{"text":"What you will do","content":"<li>Lead a unit of AML/CFT professionals focused on the various elements of an AML/CFT program;</li><li>A pointed person for any Regulatory Compliance matters/projects as well as internal or external auditors in compliance reviews.</li><li>As an industry expert, keep track of the latest developments around regulations and find smart solutions to mitigate ML/TF risks;&nbsp;</li><li>Remain knowledgeable of new or changing regulation, regulatory expectations, market conditions and industry best practices and find smart solutions to mitigate ML/TF risks;</li><li>Ensure Subject Matter Experts participate in all activities where expertise is required, including but not limited to, risk assessments, policy writing, training development, advice to the business, monitoring activities, and reporting;</li><li>Provide senior management with actionable advice on how to effectively manage AML/CFT-related risks;</li><li>Ensure all regulatory reporting requirements related to AML/CFT themes are met;</li><li>Ensure implementation AML CFT regular trainings as well to Business Unit and Support Function and to liaise with the Learning &amp; Development PAC</li>"},{"text":"What you will need","content":"<li>A minimum of 5 years in a senior leadership role in the AML/CFT</li><li>You have extensive knowledge of payments and or banking/finance industry</li><li>A thorough understanding of AML/CFT laws and regulations incl. risks, controls, industry best practices and regulatory requirements</li><li>Excellent and direct communicator who talks straight without being rude</li><li>&nbsp;You have the ability to clearly explain AML CFT compliance and related risks, develop sound mitigation strategies and find workable solutions</li><li>&nbsp;You have extensive experience representing and leading meetings with regulatory agencies, examiners and auditors</li><li>You have the ability to structure and prioritize in a high volume, fast-paced environment and drive a process to completion</li><li>You are a team player that does not shy away from taking ownership</li>"}],"text":"AML/CFT Manager - Fintech - MAB","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at MAB (PT Multifinance Anak Bangsa).Head of AML CFT is responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity she will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).Finally, as a member of the Compliance AML CFT Team, will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Manager must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</span></div>","descriptionBodyPlain":"About the Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at MAB (PT Multifinance Anak Bangsa).Head of AML CFT is responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity she will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).Finally, as a member of the Compliance AML CFT Team, will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Manager must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/365ef8c5-c4b7-4aab-9d0d-eabea5ef448b","applyUrl":"https://jobs.lever.co/GoToGroup/365ef8c5-c4b7-4aab-9d0d-eabea5ef448b/apply"},{"additionalPlain":"Our merchant team is based in Ho Chi Minh City and Hanoi, Vietnam and we have one main goal: to strengthen our GoFood market share in Vietnam. The merchant team aims to create an ecosystem of solutions to support our partner merchants on the Gojek platform to manage better and grow their business. \n\nOur partner merchants are one of the core stakeholders in our Gojek ecosystem. When you are part of the Merchant team, you will find yourself working very closely with our partner merchants to understand their daily needs and concerns and relay these insights to build platforms and operational excellence processes to ensure our partner merchant's success on the Gojek platform. We aim to establish Gojek as the most trusted partner for all our merchant-Merchants.\n\nWe’re a tight-knit, high-functioning team who genuinely love what we do, as we can see the results of our efforts play out in our merchant-Merchants’ everyday lives. When we aren’t working, you’d probably find us with our noses in books, or our eyes glued to the TV screen watching the latest Korean dramas on Netflix. We also prioritize self-care and wellness, equally concerned with each others’ personal and professional developments.\n\n","additional":"<div><span style=\"font-size: 9pt\">Our merchant team is based in Ho Chi Minh City and Hanoi, Vietnam and we have one main goal: to strengthen our GoFood market share in Vietnam. The merchant team aims to create an ecosystem of solutions to support our partner merchants on the Gojek platform to manage better and grow their business.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">Our partner merchants are one of the core stakeholders in our Gojek ecosystem. When you are part of the Merchant team, you will find yourself working very closely with our partner merchants to understand their daily needs and concerns and relay these insights to build platforms and operational excellence processes to ensure our partner merchant's success on the Gojek platform. We aim to establish Gojek as the most trusted partner for all our </span><a href=\"http://merchant-Merchants.We\" style=\"font-size: 9pt\" class=\"postings-link\">merchant-Merchants.</a></div><div><br></div><div><a href=\"http://merchant-Merchants.We\" style=\"font-size: 9pt\" class=\"postings-link\">We</a><span style=\"font-size: 9pt\">’re a tight-knit, high-functioning team who genuinely love what we do, as we can see the results of our efforts play out in our merchant-Merchants’ everyday lives. When we aren’t working, you’d probably find us with our noses in books, or our eyes glued to the TV screen watching the latest Korean dramas on Netflix. We also prioritize self-care and wellness, equally concerned with each others’ personal and professional developments.</span></div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Sales","location":"Hanoi","team":"-","allLocations":["Hanoi"]},"createdAt":1716869834706,"descriptionPlain":"Fasten your helmet and climb aboard if you’re ready to be our Hanoi-based Account Executive. Based in Hanoi, Vietnam, you will be an integral player of the Account Management Team within the larger Merchant team focusing on our GoFood business! The gist of your role will be to manage our top and most important accounts in GoFood as our Account Management Executive . The cherry on top: you’ll get to be a part of a team that works tirelessly to provide the best experience for our partner merchants, keeping them happy, engaged, and informed! We are looking to hire an Account Executive for Hanoi to look after our top local merchant partners.\n","description":"<div><span style=\"font-size: 9pt\">Fasten your helmet and climb aboard if you’re ready to be our Hanoi-based Account Executive. Based in Hanoi, Vietnam, you will be an integral player of the Account Management Team within the larger Merchant team focusing on our GoFood business! The gist of your role will be to manage our top and most important accounts in GoFood as our Account Management Executive . The cherry on top: you’ll get to be a part of a team that works tirelessly to provide the best experience for our partner merchants, keeping them happy, engaged, and informed! We are looking to hire an Account Executive for Hanoi to look after our top local merchant partners.</span></div>","id":"582fed88-5070-4a4b-8ef2-4a9a55e43d92","lists":[{"text":"What You Will Do","content":"<li>Develop long-term relationships with a portfolio of major &amp; strategic merchants, lead engagement, provide best-fitted Gojek solutions that will generate sales, and enable the delivery of joint business plans/targets</li><li>Obtain an in-depth and robust understanding of both Gojek &amp; merchant’s business needs/issues</li><li>Develop end-to-end joint business plans, monitor merchant’s performance versus target, create sales forecast based on Gojek’s plans &amp; campaigns, assess competitive benchmarking, and anticipate potential business challengesInvolved in exciting internal projects to improve the overall merchant’s pain point</li><li>Take responsibility for all services that Gojek delivers to each account, become the single point of contact from Gojek for engagement, project delivery &amp; troubleshooting efforts.&nbsp;</li><li>Perform competitive intelligence to ensure our promotion has competitive differentiation for Partner Merchants on GoFood</li><li>Working across functional units to tailor merchant specific needs while driving ROI (e.g. customized reporting, API integrations, Gobiz troubleshooting)</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Proven working experience in Account Management and/or Sales</li><li>Hold a bachelor or master degree in marketing, management, or any other related fields</li><li>Experience delivering client-focused solutions to customer needs</li><li>Proven ability to manage multiple account projects at a time, while maintaining sharp attention to detail</li><li>Understanding technology, business, marketing and innovation</li><li>Ability to work effectively with people at all levels in the organization</li><li>Solid experience with office software, particularly MS Excel</li><li>Excellent listening, negotiation and presentation abilities</li><div><br></div>"}],"text":"Area Account Executive - Hanoi","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Fasten your helmet and climb aboard if you’re ready to be our Hanoi-based Account Executive. Based in Hanoi, Vietnam, you will be an integral player of the Account Management Team within the larger Merchant team focusing on our GoFood business! The gist of your role will be to manage our top and most important accounts in GoFood as our Account Management Executive . The cherry on top: you’ll get to be a part of a team that works tirelessly to provide the best experience for our partner merchants, keeping them happy, engaged, and informed! We are looking to hire an Account Executive for Hanoi to look after our top local merchant partners.</span></div>","descriptionBodyPlain":"Fasten your helmet and climb aboard if you’re ready to be our Hanoi-based Account Executive. Based in Hanoi, Vietnam, you will be an integral player of the Account Management Team within the larger Merchant team focusing on our GoFood business! The gist of your role will be to manage our top and most important accounts in GoFood as our Account Management Executive . The cherry on top: you’ll get to be a part of a team that works tirelessly to provide the best experience for our partner merchants, keeping them happy, engaged, and informed! We are looking to hire an Account Executive for Hanoi to look after our top local merchant partners.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/582fed88-5070-4a4b-8ef2-4a9a55e43d92","applyUrl":"https://jobs.lever.co/GoToGroup/582fed88-5070-4a4b-8ef2-4a9a55e43d92/apply"},{"additionalPlain":"Our Regional Consumer Engagement team is a family of 17 people based in Indonesia, specifically in Jabodetabek region. We oversee all things and act as a center of excellence for partnerships and increasing potential visibility in respective region POI or malls and work to create (consumer engagement and brand awareness. It’s our job to ensure that all engagement activities run seamlessly. One of the biggest challenges we had to face is to ensure gojek domination is consistent across Jabodetabek region. We eventually resolved it by doing close coordination with HQ and the regional team. Currently, we’re busy at work on various projects, including one about POI domination, merchants branding.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>Our Regional Consumer Engagement team is a family of 17 people based in Indonesia, specifically in Jabodetabek region. We oversee all things and act as a center of excellence for partnerships and increasing potential visibility in respective region POI or malls and work to create (consumer engagement and brand awareness. It’s our job to ensure that all engagement activities run seamlessly. One of the biggest challenges we had to face is to ensure gojek domination is consistent across Jabodetabek region. We eventually resolved it by doing close coordination with HQ and the regional team. Currently, we’re busy at work on various projects, including one about POI domination, merchants branding.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713419462921,"descriptionPlain":"They say no man is an island - a notion that holds particularly true for this role. As our CE Associate, you’ll be an instrumental cog in the Jabodetabek Consumer Engagement team) wheel of Gojek that directly impacts the company’s (brand awareness and activation). Collaborating with (marketing and regional team), your main objective will be to (drive consumer engagement through creating mall partnership (Jakarta and Bodetabek) strategy and plan according to local insight in the region). You will have ample opportunity to flex your analytical and creative skill at the same time, and deep consumer understanding, skills, and dive deep into projects surrounding looking for growth opportunities by tailoring local insight into partnership strategy), collectively getting us even closer to (engage more consumer).\n\nWhat you will do\n\n- Support Area Senior Manager for driving consumer engagement focus areas in terms of engagement, partnership with local POI, mall in which will deliver POI domination, POS merchants branding, standard package that will deliver Region target completed orders and active users.\n- Creating consumer engagement strategy and plan according to local insight, merchants branding & POI domination and HQ driven initiative amplifications for the region. \n- Overseeing completed order transaction and MTU achievement vs target in regular basis, immediate actions to fill the gap if any \n- Manage regional/local insight generation for idea creation, translating into key actionable initiatives to build relevance with local residences.\n\nWhat you will need \n\n- Bachelor degree from top university or  any well-known universities from each region) or abroad with GPA > 3.2 or equivalent\n- Preferably majoring in Marketing Management or Business\n- At least 3-4 years of working experience in marketing\n- Solid experience in partnership\n- Good understanding of local knowledge & demonstrate excellent in Digital Marketing Campaign\n- Able to teach related Consumer Engagement knowledge to all CE team\n- Easily adapt to change, shows flexibility, prioritisation, organisation and time management skills\n- Excellent communication skills with demonstrated interpersonal flexibility and strong team management skills\n\n","description":"<div><span style=\"font-size: 10pt\">They say no man is an island - a notion that holds particularly true for this role. As our CE Associate, you’ll be an instrumental cog in the Jabodetabek Consumer Engagement team) wheel of Gojek that directly impacts the company’s (brand awareness and activation). Collaborating with (marketing and regional team), your main objective will be to (drive consumer engagement through creating mall partnership (Jakarta and Bodetabek) strategy and plan according to local insight in the region). You will have ample opportunity to flex your analytical and creative skill at the same time, and deep consumer understanding, skills, and dive deep into projects surrounding looking for growth opportunities by tailoring local insight into partnership strategy), collectively getting us even closer to (engage more consumer).</span></div><div><br></div><div><b style=\"font-size: 18px\">What you will do</b></div><div><br></div><div>- Support Area Senior Manager for driving consumer engagement focus areas in terms of engagement, partnership with local POI, mall in which will deliver POI domination, POS merchants branding, standard package that will deliver Region target completed orders and active users.</div><div>- Creating consumer engagement strategy and plan according to local insight, merchants branding &amp; POI domination and HQ driven initiative amplifications for the region.&nbsp;</div><div>- Overseeing completed order transaction and MTU achievement vs target in regular basis, immediate actions to fill the gap if any&nbsp;</div><div>- Manage regional/local insight generation for idea creation, translating into key actionable initiatives to build relevance with local residences.</div><div><br></div><div><b style=\"font-size: 18px\">What you will need</b>&nbsp;</div><div><br></div><div>- Bachelor degree from top university or&nbsp; any well-known universities from each region) or abroad with GPA &gt; 3.2 or equivalent</div><div>- Preferably majoring in Marketing Management or Business</div><div>- At least 3-4 years of working experience in marketing</div><div>- Solid experience in partnership</div><div>- Good understanding of local knowledge &amp; demonstrate excellent in Digital Marketing Campaign</div><div>- Able to teach related Consumer Engagement knowledge to all CE team</div><div>- Easily adapt to change, shows flexibility, prioritisation, organisation and time management skills</div><div>- Excellent communication skills with demonstrated interpersonal flexibility and strong team management skills</div><div><br></div>","id":"c5a0d0c2-5bcc-4ee3-ac4f-ccfc29fee0f1","lists":[],"text":"Area CE Associate - Central Jakarta","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">They say no man is an island - a notion that holds particularly true for this role. As our CE Associate, you’ll be an instrumental cog in the Jabodetabek Consumer Engagement team) wheel of Gojek that directly impacts the company’s (brand awareness and activation). Collaborating with (marketing and regional team), your main objective will be to (drive consumer engagement through creating mall partnership (Jakarta and Bodetabek) strategy and plan according to local insight in the region). You will have ample opportunity to flex your analytical and creative skill at the same time, and deep consumer understanding, skills, and dive deep into projects surrounding looking for growth opportunities by tailoring local insight into partnership strategy), collectively getting us even closer to (engage more consumer).</span></div><div><br></div><div><b style=\"font-size: 18px;\">What you will do</b></div><div><br></div><div>- Support Area Senior Manager for driving consumer engagement focus areas in terms of engagement, partnership with local POI, mall in which will deliver POI domination, POS merchants branding, standard package that will deliver Region target completed orders and active users.</div><div>- Creating consumer engagement strategy and plan according to local insight, merchants branding &amp; POI domination and HQ driven initiative amplifications for the region.&nbsp;</div><div>- Overseeing completed order transaction and MTU achievement vs target in regular basis, immediate actions to fill the gap if any&nbsp;</div><div>- Manage regional/local insight generation for idea creation, translating into key actionable initiatives to build relevance with local residences.</div><div><br></div><div><b style=\"font-size: 18px;\">What you will need</b>&nbsp;</div><div><br></div><div>- Bachelor degree from top university or&nbsp; any well-known universities from each region) or abroad with GPA &gt; 3.2 or equivalent</div><div>- Preferably majoring in Marketing Management or Business</div><div>- At least 3-4 years of working experience in marketing</div><div>- Solid experience in partnership</div><div>- Good understanding of local knowledge &amp; demonstrate excellent in Digital Marketing Campaign</div><div>- Able to teach related Consumer Engagement knowledge to all CE team</div><div>- Easily adapt to change, shows flexibility, prioritisation, organisation and time management skills</div><div>- Excellent communication skills with demonstrated interpersonal flexibility and strong team management skills</div><div><br></div>","descriptionBodyPlain":"They say no man is an island - a notion that holds particularly true for this role. As our CE Associate, you’ll be an instrumental cog in the Jabodetabek Consumer Engagement team) wheel of Gojek that directly impacts the company’s (brand awareness and activation). Collaborating with (marketing and regional team), your main objective will be to (drive consumer engagement through creating mall partnership (Jakarta and Bodetabek) strategy and plan according to local insight in the region). You will have ample opportunity to flex your analytical and creative skill at the same time, and deep consumer understanding, skills, and dive deep into projects surrounding looking for growth opportunities by tailoring local insight into partnership strategy), collectively getting us even closer to (engage more consumer).\n\nWhat you will do\n\n- Support Area Senior Manager for driving consumer engagement focus areas in terms of engagement, partnership with local POI, mall in which will deliver POI domination, POS merchants branding, standard package that will deliver Region target completed orders and active users.\n- Creating consumer engagement strategy and plan according to local insight, merchants branding & POI domination and HQ driven initiative amplifications for the region. \n- Overseeing completed order transaction and MTU achievement vs target in regular basis, immediate actions to fill the gap if any \n- Manage regional/local insight generation for idea creation, translating into key actionable initiatives to build relevance with local residences.\n\nWhat you will need \n\n- Bachelor degree from top university or  any well-known universities from each region) or abroad with GPA > 3.2 or equivalent\n- Preferably majoring in Marketing Management or Business\n- At least 3-4 years of working experience in marketing\n- Solid experience in partnership\n- Good understanding of local knowledge & demonstrate excellent in Digital Marketing Campaign\n- Able to teach related Consumer Engagement knowledge to all CE team\n- Easily adapt to change, shows flexibility, prioritisation, organisation and time management skills\n- Excellent communication skills with demonstrated interpersonal flexibility and strong team management skills\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c5a0d0c2-5bcc-4ee3-ac4f-ccfc29fee0f1","applyUrl":"https://jobs.lever.co/GoToGroup/c5a0d0c2-5bcc-4ee3-ac4f-ccfc29fee0f1/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Bali","team":"East Java, Bali, Nusra Regions","allLocations":["Bali"]},"createdAt":1703134039485,"descriptionPlain":"About The Role\n\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","id":"4220480a-be7c-4f31-8d6b-59a21558b594","lists":[{"text":"What You Will Do","content":"<li>Support Area Head to drive consumer engagement focus areas in terms of Visibility &amp; Partnership which will deliver POI domination, POS merchants branding, standard package that will deliver Area target completed orders and active users.</li><li>Managing all day to day marketing executional activities from all areas needed to deliver the consumer engagement plans. e.g. contract, PO, invoice, etc.</li><li>Ensure all consumer engagement activities in areas are delivered with a given standard of accuracy, completeness, timeliness as per the standard package and local initiatives.&nbsp;</li><li>Externally supervise vendors/daily workers in executing merchant branding and POI domination on a regular basis.&nbsp;Internally work with direct responsibility to deliver area executions and targets by executing events, exhibits, and other activities.</li><li>Good with data to develop and execute clear integrated strategies of digital marketing with clear metrics and excellent results.</li><li>Responsible for setting the integrated communications plan and ensuring consistency of messaging and brand communications. Working closely with the sales, government relations, and operations team.</li>"},{"text":"What You Will Need","content":"<li>Minimum 2&nbsp; years of working experience in Marketing/Sales, preferaby from global FMCG Company</li><li>Good understanding of local knowledge</li><li>Strong analytical and planning skills</li><li>Good communication and presentation skills</li><li>Excellent problem-solving skill with the ability to play it well independently and in a team</li><li>Good collaboration with compassion and proactiveness</li><li>Agile and fast in thinking and execution</li><li><b>Willing to be based in Bali</b></li>"}],"text":"Area Consumer Engagement Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","descriptionBodyPlain":"About The Role\n\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4220480a-be7c-4f31-8d6b-59a21558b594","applyUrl":"https://jobs.lever.co/GoToGroup/4220480a-be7c-4f31-8d6b-59a21558b594/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Bandung","team":"-","allLocations":["Bandung"]},"createdAt":1716603127529,"description":"","descriptionPlain":"","id":"95352b3a-e239-4d08-8e8a-aeedba71872e","lists":[{"text":"What you will do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;driver acquisition management, driver engagement management (loyalty &amp; retention and safety &amp; performance training), driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant), driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, ProEnsure SOP and legal compliances in the areamo Go)</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support ROH in product changes roll out in the region</li>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking and problem solving skills using various improvement tools and methods</li><li>Having good understanding about supply and demand planning</li><li>Having good communication skills and good attention to detail and routine activities</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Able to handle communication in community or mass conflict&nbsp;</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written in English</li><li>Having Six Sigma Black Belt Certification is an advantage</li>"}],"text":"Area Operations Manager - Bandung","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/95352b3a-e239-4d08-8e8a-aeedba71872e","applyUrl":"https://jobs.lever.co/GoToGroup/95352b3a-e239-4d08-8e8a-aeedba71872e/apply"},{"additionalPlain":"About the team \n\nArea Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the team </b></div><div><br></div><div><span style=\"font-size: 16px\">Area Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Depok","team":"-","allLocations":["Depok","Bogor"]},"createdAt":1713768982209,"descriptionPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"18674f77-24b2-46a4-86bb-7b5e7fe71f2c","lists":[{"text":"What You Will Do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;Driver acquisition management, Driver engagement management (loyalty &amp; retention and safety &amp; performance training), Driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant), driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li>"},{"text":"What You Will Need","content":"<li>At least 5 years experience in operations/ supply/ demand generation, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Good understanding about supply and demand planning</li><li>Prior experience in managing team (&gt; 3 members)</li><li>Good communication skills and good attention to detail and routine activities</li><li>Ability to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Capability to handle communication in community or mass conflict&nbsp;</li><li>Proficiency in English both spoken and written</li>"}],"text":"Area Operations Manager (Bogor Depok)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c","applyUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c/apply"},{"additionalPlain":"About The Team\n\nAs a Area Operations Staff, he/she will support the Area Operations Supervisor on a day to day basis. He/she will work very intensively and collaborate with other Area Operation Staff in respective area. He/she also will work closely with the drivers in the field and will be the first contact for drivers to escalate any issues.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>As a Area Operations Staff, he/she will support the Area Operations Supervisor on a day to day basis. He/she will work very intensively and collaborate with other Area Operation Staff in respective area. He/she also will work closely with the drivers in the field and will be the first contact for drivers to escalate any issues.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716868261973,"descriptionPlain":"About The Role\n\nArea Operations Staff accountable and responsible to support Area Operations Supervisor for all spectrum operation drivers at area level, including but not limited to driver engagement activity, driver acquisition, and consistently helping to solve driver problems on the field. Handle conflict, regulation compliance and maintain stakeholders in the area. \n","description":"<div><b>About The Role</b></div><div><br></div><div>Area Operations Staff accountable and responsible to support Area Operations Supervisor for all spectrum operation drivers at area level, including but not limited to driver engagement activity, driver acquisition, and consistently helping to solve driver problems on the field. Handle conflict, regulation compliance and maintain stakeholders in the area.<span style=\"font-size: 10pt\">&nbsp;</span></div>","id":"69cc5000-f892-48ae-a65c-58239123d62a","lists":[{"text":"What Will You Do","content":"<li>Handle all the driver community, marketing, and driver care responsibilities on satellite level</li><li>Handle channel walk in center on each area</li><li>Manage driver’s problems</li><li>Manage service time, driver and customer satisfaction</li><li>Coordinate with Area Operations Supervisor for day-to-day escalated issues around driver service and customer service.</li>"},{"text":"What You Will Need","content":"<li>Fresh graduate or having min. 1 years experience in related area</li><li>Bachelor degree from reputable university</li><li>Able to handle walk in channel</li><li>Experiences in face to face service</li><li>Experiences working with excel and do data visualization&nbsp;</li><li>Willing to improve driver satisfaction</li>"}],"text":"Area Operations Staff (Jakarta)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Area Operations Staff accountable and responsible to support Area Operations Supervisor for all spectrum operation drivers at area level, including but not limited to driver engagement activity, driver acquisition, and consistently helping to solve driver problems on the field. Handle conflict, regulation compliance and maintain stakeholders in the area.<span style=\"font-size: 10pt;\">&nbsp;</span></div>","descriptionBodyPlain":"About The Role\n\nArea Operations Staff accountable and responsible to support Area Operations Supervisor for all spectrum operation drivers at area level, including but not limited to driver engagement activity, driver acquisition, and consistently helping to solve driver problems on the field. Handle conflict, regulation compliance and maintain stakeholders in the area. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/69cc5000-f892-48ae-a65c-58239123d62a","applyUrl":"https://jobs.lever.co/GoToGroup/69cc5000-f892-48ae-a65c-58239123d62a/apply"},{"additionalPlain":"About The Team\n\nOur Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners. \n\nOne of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team. \n\nOur team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">One of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Tangerang","team":"-","allLocations":["Tangerang"]},"createdAt":1716869065162,"descriptionPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","id":"8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","lists":[{"text":"What You Will Do","content":"<li>List, identify, and propose solutions to our driver partners' problems on the field and ensure their concerns are heard by following up with them</li><li>Manage offline engagement (i.e. 'kopdar') as our way to inform, reach, and engage with driver partners</li><li>Ensure all engagement programs are well executed and implemented</li><li>Handle driver support unit according to agreed operating office hours</li><li>Support implementation of Gojek's policies/programs by managing these changes</li><li>Propose activities/programs to engage our driver partners</li><li>Monitor personal metrics of engagement with driver partners, and propose solutions to increase the level of engagement</li>"},{"text":"What You Will Need","content":"<li>A Bachelor's degree (fresh graduates are welcome to apply!)</li><li>At least 1 year of experience in supply chain, preferably at a multinational company</li><li>Strong analytical thinking and problem-solving skills to effectively resolve driver-related issues</li><li>Strong interpersonal skills in order to cater and build relationships with various stakeholders</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Sharp attention to detail to increase productivity and reduce the likelihood of errors</li><li>Excellent planning and organizational abilities to ensure the area team is on track to achieve its goals</li><li>An understanding about/familiarity with the Tangerang region</li>"}],"text":"Area Operations Staff (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","descriptionBodyPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","applyUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2/apply"},{"additional":"","additionalPlain":"","categories":{"department":"ODS - Regions","location":"Balikpapan","team":"Emerging Market","allLocations":["Balikpapan"]},"createdAt":1719223321521,"description":"","descriptionPlain":"","id":"95ee9a06-a46d-43a2-a8e7-003de776404d","lists":[{"text":"What you will do:","content":"<li>Handle all the driver community, marketing, and driver care responsibilities on areas level and channel walk in center on each area;</li><li>Ensure problem solving according to agreed process &amp; based on standard operational procedure;</li><li>Manage driver’s problems and empowerment;</li><li>Coordinate with Area Operations Manager for day-to-day escalated issues around driver service and customer service to manage service time, driver and customer satisfaction;</li><li>Developing the marketing strategy for the company in line with company objectives;</li><li>Conceptualizes events, exhibits and other below the line marketing based on the marketing plan, and evaluate the effectiveness of all marketing activities;</li><li>Maintain effective internal communications to ensure that all relevant company functions are kept informed of marketing objectives.</li>"},{"text":"What you will need:","content":"<li>Having a minimum of 3 years experience in related fields;</li><li>Bachelor degree from top university any well-known universities from each region with GPA &gt; 3.2 or equivalent;</li><li>Passionate about community development, having relevant previous experience would be preferred;</li><li>Experience launching community initiatives (building an online forum, launching an ambassador program, creating an event series, etc.);</li><li>Ability to identify and track relevant community and market metrics;</li><li>Excellent verbal communication and writing skills;</li><li>Having a basic of data analytics;</li><li>Willing to relocate to a selected area.</li>"}],"text":"Area Operations Supervisor - Balikpapan","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d","applyUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716602705785,"description":"","descriptionPlain":"","id":"8c7385d0-98c1-41d8-b780-6c84ed6c40ad","lists":[{"text":"What you will do:","content":"<li>Design an overall merchant strategy (encompassing both hunting and farming motion) for the Area, followed by implementation and execution of the plan to ensure business objectives are achieved</li><li>Oversee and manage the performance of his/her team (consisting of at least AE &amp; AM)</li><li>Review team performance and take corrective actions &nbsp;to achieve target.</li><li>Cascade strategy from RSH &amp; Sales Strategy HQ to the team &amp; lead the execution for the Area.</li><li>Coach AE &amp; AM to Identify new sales opportunities within existing merchant accounts by up-selling and cross-selling existing products.                                                                                                                                                                                                  </li><li>Support his/her team to problem solve issues happening in their area, especially issues happening at critical merchants.</li><li>Regularly do coaching &amp; mentoring for the team members</li><li>Identify key/critical merchants in the Area including: Build and maintain relationships with these merchants                                                                                and Give additional support to the AE/AM managing the merchants to problem solve issues experienced by these merchants</li><li>Work with relevant stakeholders in the region/area to ensure that sales strategies &amp; merchant activities are aligned with the overall regional and nationwide company objectives. This would include supporting the RCE team to translate consumer behavior, market insight, field situation, and market trend within the district to refine the overall region strategy.</li><li>Know when to escalate &amp; ask help from RSH for bigger issues</li>"},{"text":"What you will need :","content":"<li>Bachelor's degree in any field (Top tier University is preferable) and willing to relocate to another city</li><li>5-7 years of experience within mid-to-senior management function (FMCG, SMB Banking and Telecom company)</li><li>Strong network and knowledge about the city</li><li>Excellence to bridge, develop and maintain good relationships with key partners such as but not limited to local/regional government stakeholders, 3rd party partners, merchant associations, communities</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Strong leadership and interpersonal skills, experienced in managing a big team, as well as strong in people development and mentoring / coaching</li><li>Strong written &amp; communication skills, fluent in English and Bahasa Indonesia</li><li>Fact-based/number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"},{"text":"About the team:","content":"<li>Area Sales Manager (ASM) will work within direct command of Area Head and matrix collaboratively with the region sales team on some projects. You will lead the Sales team consisting of Account Manager (AM) &amp; Account Executive (AE) for Surabaya &amp; Malang areas. as ASM regularly visits with AM &amp; AE to their assigned merchants across their areas to see what really happened on the ground as well as providing advance advice to them in increasing transaction overtime.</li>"}],"text":"Area Sales Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/8c7385d0-98c1-41d8-b780-6c84ed6c40ad","applyUrl":"https://jobs.lever.co/GoToGroup/8c7385d0-98c1-41d8-b780-6c84ed6c40ad/apply"},{"additionalPlain":"About The Team\n\nOur tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!  \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">Our tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!&nbsp;&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697204557563,"descriptionPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","description":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","id":"56966262-038f-497f-84c1-f360a9440c55","lists":[{"text":"What You Will Do","content":"<li>Manage tax compliance matters; including preparation of monthly and annual tax calculation/payment/returns, i.e. WHT, VAT, CIT)</li><li>Manage and advise day-to-day business initiatives including decisive actions toward dynamic business products</li><li>Manage and handle restructuring projects independently with supervision from the AVP of Tax</li><li>Able to communicate and align with relevant stakeholders within the group</li><li>Monitoring any tax regulation updates, identifying relevant business areas that may be impacted, and planning the risk mitigation strategy</li><li>Able to support the litigation process and assessment of risks</li><li>Able to support the advocacy initiatives within the relevant external organizations.</li>"},{"text":"What You Will Need","content":"<li>S1 Bachelor of Economics (majoring in accounting or corporate finance) or Bachelor of Social Finance (Majoring in Fiscal Administration) </li><li>Minimum 5 years of working experience in the taxation field</li><li>Strong interpersonal, analytical, communication, and presentation skills with advanced command of written and spoken English</li><li>Strong technical skills in tax, accounting, and corporate finance</li><li>Ability to work in a fast-paced, rapidly changing, and high-growth environment</li><li>Able to work independently and in a team</li>"}],"text":"Assistant Tax Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","descriptionBodyPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55","applyUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718870141721,"descriptionPlain":"About the Role :\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp;&nbsp;</div><div><br></div><div><br></div>","id":"d3060482-4566-44a1-8f48-5d05dde1ad63","lists":[{"text":"What You Will Do","content":"<li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Be responsible for development of functional/nonfunctional requirements and OKRs and while owning the entire lifecycle of dev, test, deployment, documentation, bug fixes and improvements</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Work with tech leads to progress on the group’s and organization’s goals</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Providing and accepting positive criticism and feedback</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Strong understanding of programming fundamentals with Golang or Java</li><li>Proficient in OOP, SQL, Design Patterns</li><li>In-depth knowledge of unit testing methodologies, OS/networking and other CS fundamentals</li><li>Ability to communicate well your ideas, coupled with the capability to skillfully question and challenge the existing norms</li><li>Having an attitude of questioning the current why things work the way they do and interest in deep diving into problems</li><li>Passion for learning new technologies and up-to-date knowledge of popular open source releases</li><div><br></div>"}],"text":"Associate Software Engineer - Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp;&nbsp;</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d3060482-4566-44a1-8f48-5d05dde1ad63","applyUrl":"https://jobs.lever.co/GoToGroup/d3060482-4566-44a1-8f48-5d05dde1ad63/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716278898371,"descriptionPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","description":"<div><span style=\"font-size: 16px\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","id":"2242125a-7155-4353-bc79-473d237d6808","lists":[{"text":"What You WIll Do","content":"<li>Be the expert in using data to measure and analyze business performance.</li><li>Explore business issues/opportunities, uncover insights and/or identify targeted areas for business growth.</li><li>Lead new data analytics capability rollouts and/or data-led initiatives throughout organization.</li><li>Monitor key metrics and alert the business on potential issues.</li><li>Analyze operational efficiency and build business models to guide decision-making.</li><li>Design market/business intelligence reports and performance measurement dashboards to share with senior management.</li><li>Able to analyze business performance following the analysis framework.</li><li>Able to create reports/ dashboards individually.</li><li>Collaborates with business stakeholders to gather requirements and deliver actionable insights.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Statistics, Business Administration, or a related field.</li><li>2-5 years of experience in a BI or analytics role.</li><li>Proficiency in SQL and database management systems like MySQL, SQL Server, or Oracle.</li><li>Advanced knowledge of data modeling and data warehousing concepts.</li><li>Strong understanding of business processes and the ability to translate business requirements into technical solutions.</li><li>Familiarity with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Experience with BI reporting tools and dashboard development.</li><li>Proven ability to work with cross-functional teams and manage stakeholders.</li><li>Familiarity with business operations in the field.</li>"}],"text":"Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","descriptionBodyPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808","applyUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808/apply"},{"additionalPlain":"About The Team\n\nCost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Cost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.</div>","categories":{"commitment":"Permanent","department":"FinTech - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718852731439,"descriptionPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","id":"60283bc5-9f60-400a-8289-bcbe332fbc09","lists":[{"text":"What You Will Do","content":"<li><b>Planning</b>: Work closely with the budget owner to prepare annual budget planning, re-forecast, rolling forecast on a periodic business cycle. Review budget activities completed by the budget owner with accurate baseline, information, and proper justification</li><li><b>Controlling</b>: Responsible for reviewing and approving each spending related to Opex and Capex according to the applicable Expense Management PolicyWork closely with the budget owner to ensure each spending request is based on business requirements, supported by budget availability, and budget transfer process (if required). Collaborate with the other stakeholders in building the right cost base e.g., Procurement, Budget owner, etc.</li><li><b>Monitoring</b>: Create and refine report in order to provide the right data and information to the CFO, FBP and Budget Owner to analyze the actual spends against the available budget on monthly basis with a pre-defined report including its associated drivers. Understand the variance including the explanation and/or justification from the Budget Owner whenever the spend exceeded the approved budget. Continue to work closely with the Budget Owner in supporting the identification of risks &amp; opportunities for cost-efficiency purposes. Highlight key financial issues and deliver the proposed solutions to the stakeholders, provide insightful financial analysis on a regular and ad-hoc basis such as but not limited to topline daily/weekly tracker, business unit performance review, and other financial ratios analysisIn certain circumstances, this candidate will work with Cost Management Head to support the entire products under GoTo Financial product or Function group.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's Degree in Accounting / Finance/ Business, or equivalent educational background</li><li>Minimum 5 years of working experience in Finance Business Partner / Cost Control areas</li><li>Able to build a financial model, proficiency in Microsoft Excel and Gsheet/Gdocs</li><li>Strong business, data-driven acumen, and ability to work with big database</li><li>Able to manage multiple stakeholders across various levels of seniority</li><li>Strong project management skills to manage complex projects; able to prioritize multiple internal and external stakeholders; and able to drive consensus</li><li>Strong team player; possesses team synergy skills with a high level of enthusiasm in collaborating with cross-teams</li><li>Able to work independently and high attention to detail with swift execution</li><li>Proficiency with Finance / Accounting tools (e.g. SAP and ERP) is a plus</li><li>Fluent in English (written and spoken)</li>"}],"text":"Cost Management Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","descriptionBodyPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09","applyUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. \nWe want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines. We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><b style=\"font-size: 16px\">About The Team</b></div><div><br></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. </span></div><div><span style=\"font-size: 16px\">We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines. We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression </span><b style=\"font-size: 16px\">😎</b><span style=\"font-size: 16px\"> If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div>","categories":{"department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718077718668,"descriptionPlain":"About The Role\n\nAs Creative Director, you will be an integral player in the Creative team, taking the wheel in driving our 360 advertising campaigns for our wide array of products and services. With the folks in the Marketing and Branding teams, you’ll translate marketing objectives into creative execution, formulating the right communication strategies to tell effective, relatable, and relevant product stories. \nYour efforts will help introduce Gojek’s products and services to a wider audience, propelling us to more corners of the globe. You will be fostering collaboration among team members, balancing creative freedom with strategic objectives, and staying ahead of industry trends to maintain a competitive edge.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Creative Director, you will be an integral player in the Creative team, taking the wheel in driving our 360 advertising campaigns for our wide array of products and services. With the folks in the Marketing and Branding teams, you’ll translate marketing objectives into creative execution, formulating the right communication strategies to tell effective, relatable, and relevant product stories. </span></div><div><span style=\"font-size: 16px\">Your efforts will help introduce Gojek’s products and services to a wider audience, propelling us to more corners of the globe. You will be fostering collaboration among team members, balancing creative freedom with strategic objectives, and staying ahead of industry trends to maintain a competitive edge.</span></div>","id":"805e2dcd-40aa-4655-85c2-380114ac8292","lists":[{"text":"What You Will Do","content":"<li>Provide strategic and creative direction for all marketing initiatives, ensuring alignment with brand objectives and target audience preferences</li><li>Conceptualize and oversee the execution of compelling 360 advertising campaigns across various mediums, including digital, print, and video</li><li>Establish and maintain brand guidelines and standards to ensure consistency and coherence across all creative assets</li><li>Evaluate campaign performance and incorporate feedback to optimize creative strategies and improve results</li><li>Stay abreast of industry trends, emerging technologies, and best practices to inform creative decisions and maintain a competitive edge</li>"},{"text":"What You Will Need","content":"<li>Proven experience (3 years) in a creative leadership role, with a track record of delivering impactful campaigns and leading high-performing teams</li><li>A strong portfolio showcasing creative excellence across various mediums, with a focus on strategic thinking, storytelling, and visual aesthetics</li><li>Exceptional communication and presentation skills, with the ability to articulate creative concepts and strategies</li><li>Strategic thinking and a deep understanding of branding, marketing, and consumer behavior, with the ability to translate insights into effective creative solutions</li><li>A passion for creativity, innovation, and pushing boundaries to deliver groundbreaking work that resonates with audiences and drives results</li>"}],"text":"Creative Director","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Creative Director, you will be an integral player in the Creative team, taking the wheel in driving our 360 advertising campaigns for our wide array of products and services. With the folks in the Marketing and Branding teams, you’ll translate marketing objectives into creative execution, formulating the right communication strategies to tell effective, relatable, and relevant product stories. </span></div><div><span style=\"font-size: 16px;\">Your efforts will help introduce Gojek’s products and services to a wider audience, propelling us to more corners of the globe. You will be fostering collaboration among team members, balancing creative freedom with strategic objectives, and staying ahead of industry trends to maintain a competitive edge.</span></div>","descriptionBodyPlain":"About The Role\n\nAs Creative Director, you will be an integral player in the Creative team, taking the wheel in driving our 360 advertising campaigns for our wide array of products and services. With the folks in the Marketing and Branding teams, you’ll translate marketing objectives into creative execution, formulating the right communication strategies to tell effective, relatable, and relevant product stories. \nYour efforts will help introduce Gojek’s products and services to a wider audience, propelling us to more corners of the globe. You will be fostering collaboration among team members, balancing creative freedom with strategic objectives, and staying ahead of industry trends to maintain a competitive edge.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/805e2dcd-40aa-4655-85c2-380114ac8292","applyUrl":"https://jobs.lever.co/GoToGroup/805e2dcd-40aa-4655-85c2-380114ac8292/apply"},{"additionalPlain":"Mobility Marketing has 20 members divided into the online ride hailing and logistic marketing team. Full of diverse backgrounds and locations, we provide the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position and continue to grow in Vietnam. \nAs a CRM, we run all things related to customer engagement and retention across the entire Gojek App. We aim to generate incremental impact from every interaction between our users and the company. How do we ensure this, you ask? By relying heavily on experiments and A/B testing for continuous improvement. Additionally, we collaborate with the talented people over in the Product, Marketing, Research, BI, Growth, Analytics, and Creative teams on a daily basis to ensure the alignment of insights, strategy, and business objectives, and to deliver the best user experience possible.\n\nOne of our team's biggest obstacles has been understanding our customers' needs and preferences towards our various services and predicting their future behaviors for preventive actions rather than reactive ones. After many weeks of research, collaboration, and trial and error, we figured out that the best way to tackle this issue was to integrate data science and machine learning into our approach, supported by campaign management tools that enable a seamless journey setup. Currently, our team has been busy working on a project surrounding automation and personalization, whose purpose is to enhance our user experience by offering relevant communication to support the larger goal in increasing Gojek active users.\n\nAs a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">Mobility Marketing has 20 members divided into the online ride hailing and logistic marketing team. Full of diverse backgrounds and locations, we provide the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position and continue to grow in Vietnam.&nbsp;</span></div><div><span style=\"font-size: 9pt\">As a CRM, we run all things related to customer engagement and retention across the entire Gojek App. We aim to generate incremental impact from every interaction between our users and the company. How do we ensure this, you ask? By relying heavily on experiments and A/B testing for continuous improvement. Additionally, we collaborate with the talented people over in the Product, Marketing, Research, BI, Growth, Analytics, and Creative teams on a daily basis to ensure the alignment of insights, strategy, and business objectives, and to deliver the best user experience possible.</span></div><div><br></div><div><span style=\"font-size: 9pt\">One of our team's biggest obstacles has been understanding our customers' needs and preferences towards our various services and predicting their future behaviors for preventive actions rather than reactive ones. After many weeks of research, collaboration, and trial and error, we figured out that the best way to tackle this issue was to integrate data science and machine learning into our approach, supported by campaign management tools that enable a seamless journey setup. Currently, our team has been busy working on a project surrounding automation and personalization, whose purpose is to enhance our user experience by offering relevant communication to support the larger goal in increasing Gojek active users.</span></div><div><br></div><div><span style=\"font-size: 9pt\">As a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715224196708,"descriptionPlain":"As our CRM Marketing, you’ll take the wheel in executing the campaign/journey implementation and development for Gojek customer lifecycle programs and communications. Working closely with the Marketing Team, Product Team, and Strategy and Planning team, you will configure technical implementation of Gojek customer lifecycle journeys and tactical communication campaigns through various inbound and outbound (non-paid) channels. You will directly impact the incremental growth of Gojek in the Indonesia market through scalable, personalized, relevant, and contextual communication and increase in the engagement and retention of our users.\n","description":"<div><span style=\"font-size: 9pt\">As our CRM Marketing, you’ll take the wheel in executing the campaign/journey implementation and development for Gojek customer lifecycle programs and communications. Working closely with the Marketing Team, Product Team, and Strategy and Planning team, you will configure technical implementation of Gojek customer lifecycle journeys and tactical communication campaigns through various inbound and outbound (non-paid) channels. You will directly impact the incremental growth of Gojek in the Indonesia market through scalable, personalized, relevant, and contextual communication and increase in the engagement and retention of our users.</span></div>","id":"59548879-6e27-4764-9378-85f7f2003a91","lists":[{"text":"What you will do","content":"<li>Implement marketing tactical campaigns via inbound (Shuffle Card, Inbox, Chatbot) and outbound channels (e.g. Email, Push Notification)</li><li>Implement lifecycle automation programs via inbound (Shuffle Card, Inbox, Chatbot) and outbound channels (e.g. Email, Push Notification)</li><li>Launch/deployment is conducted in an efficient, timely, and high quality manner</li><li>Manage the creation and updating of emails, push notifications, landing pages, forms, and reports for campaigns and webpages</li><li>Develop communication templates for consistency and effectiveness in accordance with branding guidelines and best practices</li><div><br></div>"},{"text":"What you will need","content":"<li>A BS/MS in Engineering, Computer Science, Business, Marketing, or equivalent experience</li><li>At least 1 years of CRM marketing experience, preferably within the online mobile app, e-commerce, quick commerce, e-grocery,&nbsp; telecommunications, airlines, or other relevant service industry</li><li>Proficiency in launching CRM campaign/customer journey implementation and experimentation through advanced CRM tools (e.g. Braze, Leanplum, Clevertap, SalesForce)</li><li>Good knowledge of HTML/CSS, scripting, and SQL will be a plus</li><li>Strong analytical and quantitative skills; ability to use hard data and metrics to back up assumptions, recommendations, and drive actions (e.g. Strong knowledge of conducting experimentation and A/B testing)</li><li>Excellent written &amp; verbal communication in English and Vietnamese at the business level with strong presentation skills in order to represent the Marketing team in functional meetings</li><li>Ability to work effectively within a high-pressure environment where prioritization is essential</li><div><br></div>"}],"text":"CRM Executive (Marketing)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">As our CRM Marketing, you’ll take the wheel in executing the campaign/journey implementation and development for Gojek customer lifecycle programs and communications. Working closely with the Marketing Team, Product Team, and Strategy and Planning team, you will configure technical implementation of Gojek customer lifecycle journeys and tactical communication campaigns through various inbound and outbound (non-paid) channels. You will directly impact the incremental growth of Gojek in the Indonesia market through scalable, personalized, relevant, and contextual communication and increase in the engagement and retention of our users.</span></div>","descriptionBodyPlain":"As our CRM Marketing, you’ll take the wheel in executing the campaign/journey implementation and development for Gojek customer lifecycle programs and communications. Working closely with the Marketing Team, Product Team, and Strategy and Planning team, you will configure technical implementation of Gojek customer lifecycle journeys and tactical communication campaigns through various inbound and outbound (non-paid) channels. You will directly impact the incremental growth of Gojek in the Indonesia market through scalable, personalized, relevant, and contextual communication and increase in the engagement and retention of our users.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/59548879-6e27-4764-9378-85f7f2003a91","applyUrl":"https://jobs.lever.co/GoToGroup/59548879-6e27-4764-9378-85f7f2003a91/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial Services Platform is committed to delivering top-notch financial services products to our users. We operate in a fast-paced, open, and inclusive environment where your contributions will be significant and valued. Join us to enhance your skills and knowledge alongside many experts from various teams. As the Customer Engagement Lead, you will support the Customer Engagement Manager in the operationalization of both inbound and outbound customer engagement activities. This role balances service and sales functions, ensuring our customers receive exceptional experiences with our financial services products. Your role is pivotal in fostering customer satisfaction and loyalty, making you an essential part of our dynamic team.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoTo Financial Services Platform is committed to delivering top-notch financial services products to our users. We operate in a fast-paced, open, and inclusive environment where your contributions will be significant and valued. Join us to enhance your skills and knowledge alongside many experts from various teams. As the Customer Engagement Lead, you will support the Customer Engagement Manager in the operationalization of both inbound and outbound customer engagement activities. This role balances service and sales functions, ensuring our customers receive exceptional experiences with our financial services products. Your role is pivotal in fostering customer satisfaction and loyalty, making you an essential part of our dynamic team.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717078120525,"descriptionPlain":"About The Role\n\nIn the role of Customer Engagement Lead within MAB entity, you will serve as a crucial driver of customer satisfaction and loyalty by taking part in developing and executing engagement strategies. Your duties will entail collaborating with cross-functional teams to analyze customer feedback, pinpoint areas for enhancement, and execute initiatives aimed at elevating the overall customer experience. Challenges may arise from navigating diverse customer needs while aligning with business objectives. During the initial six months, their pivotal contribution will involve supporting the Customer Engagement Manager, aiding in strategy implementation, and effecting tangible improvements in customer satisfaction metrics via targeted initiatives. \n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">In the role of Customer Engagement Lead within MAB entity, you will serve as a crucial driver of customer satisfaction and loyalty by taking part in developing and executing engagement strategies. Your duties will entail collaborating with cross-functional teams to analyze customer feedback, pinpoint areas for enhancement, and execute initiatives aimed at elevating the overall customer experience. Challenges may arise from navigating diverse customer needs while aligning with business objectives. During the initial six months, their pivotal contribution will involve supporting the Customer Engagement Manager, aiding in strategy implementation, and effecting tangible improvements in customer satisfaction metrics via targeted initiatives.&nbsp;</span></div>","id":"d25e2655-a6d3-4ff9-a818-38ac5b7b609a","lists":[{"text":"What You Will Do","content":"<li>Assist the Customer Engagement Manager in developing and executing customer engagement strategies to meet targets and objectives</li><li>Help monitor key performance indicators (KPIs) related to customer engagement and satisfaction</li><li>Collaborate with other departments to address customer inquiries, concerns, and escalations in a timely manner</li><li>Serve as a liaison between Consumer Lending and Service Excellence unit&nbsp; to ensure the seamless delivery of high-quality service to customers</li>"},{"text":"What You Will Need","content":"<li>Previous experience in telesales and customer service/customer experience management</li><li>Strong communication and interpersonal skills, with the ability to build relationships and collaborate effectively with internal teams</li><li>Organizational skills with the ability to manage multiple projects and priorities simultaneously</li><li>Customer-centric mindset with a passion for delivering exceptional customer experiences</li><li>Adaptability and flexibility to thrive in a fast-paced, dynamic environment</li>"}],"text":"Customer Engagement Lead (Telesales) - Consumer Lending - #10073","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">In the role of Customer Engagement Lead within MAB entity, you will serve as a crucial driver of customer satisfaction and loyalty by taking part in developing and executing engagement strategies. Your duties will entail collaborating with cross-functional teams to analyze customer feedback, pinpoint areas for enhancement, and execute initiatives aimed at elevating the overall customer experience. Challenges may arise from navigating diverse customer needs while aligning with business objectives. During the initial six months, their pivotal contribution will involve supporting the Customer Engagement Manager, aiding in strategy implementation, and effecting tangible improvements in customer satisfaction metrics via targeted initiatives.&nbsp;</span></div>","descriptionBodyPlain":"About The Role\n\nIn the role of Customer Engagement Lead within MAB entity, you will serve as a crucial driver of customer satisfaction and loyalty by taking part in developing and executing engagement strategies. Your duties will entail collaborating with cross-functional teams to analyze customer feedback, pinpoint areas for enhancement, and execute initiatives aimed at elevating the overall customer experience. Challenges may arise from navigating diverse customer needs while aligning with business objectives. During the initial six months, their pivotal contribution will involve supporting the Customer Engagement Manager, aiding in strategy implementation, and effecting tangible improvements in customer satisfaction metrics via targeted initiatives. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/d25e2655-a6d3-4ff9-a818-38ac5b7b609a","applyUrl":"https://jobs.lever.co/GoToGroup/d25e2655-a6d3-4ff9-a818-38ac5b7b609a/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264696268,"descriptionPlain":"\n","description":"<div><br></div>","id":"6d8ebb73-2348-423d-847e-b8a8408ac1ed","lists":[{"text":"What You Will Do","content":"<li>Gather business requirements to support BI projects.</li><li>Explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What you will need ","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Data Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed","applyUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716265340466,"description":"","descriptionPlain":"","id":"36d71dff-c9ac-44b8-b870-f74d941bd7d3","lists":[{"text":"What You Will Do","content":"<li>Design and implement complex data solutions, architecting data systems, and driving technical initiatives.</li><li>Optimize data infrastructure for performance, scalability, and reliability - working with large-scale data volumes &amp; distributed systems.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Provide technical guidance and support to ensure the successful delivery of data projects, including troubleshooting and resolving technical challenges.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>5+ years of experience in data engineering, software engineering, or a similar role.</li><li>Expertise in programming languages such as Python, Java, or Scala.</li><li>Advanced knowledge of SQL, database management systems, and data warehousing concepts.</li><li>Extensive experience with big data technologies and distributed systems.</li><li>Proven track record of designing and implementing complex data pipelines and ETL processes.</li><li>Deep understanding of cloud-based data technologies and best practices.</li><li>Leadership abilities to mentor junior team members and lead technical initiatives.</li><li>Strong problem-solving and troubleshooting skills.</li><li>Ability to communicate technical concepts effectively to both technical and non-technical stakeholders.</li>"}],"text":"Data Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3","applyUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3/apply"},{"additionalPlain":"About the Team\n\nThe Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience. \nAs a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience.&nbsp;</div><div>As a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1717749466111,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","description":"<div><span style=\"font-size: 10pt\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","id":"d93a7524-8ab9-4499-9f04-0876fcafa529","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain performance management dashboards and visualizations.&nbsp;</li><li>Provide regular analysis on operational performance metrics including transactions, conversion rate, lead quality, cost efficiency, retention, and KPI tracking to guide decision-making and devise proactive solutions.&nbsp;</li><li>Collaborate across teams to drive Operational Excellence (OPEX) and Continuous Improvement Process (CIP) initiatives, identifying growth opportunities for product, customer, driver, and optimization.&nbsp;</li><li>Support senior management with clear and concise presentations of complex data sets for informed decision-making.&nbsp;</li><li>Build, automate, and enhance reporting, data logging, and data pipelines for availability, integrity, accuracy, and reliability, ensuring security and compliance.&nbsp;</li><li>Assist in report compilation, issue investigation, and liaison with internal and external stakeholders for regulatory compliance.</li>"},{"text":"What You Will Need","content":"<li>Bachelors' Degree in Economics, Computer Science, Engineering, Mathematics or Statistics.&nbsp;</li><li>Minimum 5 years experience with 3+ years of relevant experience in analytics and product/process improvement.&nbsp;</li><li>Proficient in analyzing large datasets and translating quantitative findings into actionable insights.&nbsp;</li><li>Excellent understanding of analytics, computational modeling, business needs analysis, data visualization, and stakeholder management.&nbsp;</li><li>Resilience and initiative in a fast-paced, dynamic environment&nbsp;</li><li>Proficient in SQL; experience in BI tools such as Tableau, Metaforce, Python or Looker is a plus&nbsp;</li><li>Prior experience demonstrating strong stakeholder engagement and vendor management skills is a plus</li>"}],"text":"Data Operations Analyst","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529","applyUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529/apply"},{"additionalPlain":"About the Team\n\nOur Data Warehouse team is one of the key teams to bring data into critical information and knowledge that can be used to make sound business resolutions. We are hardening the bridges by working closely with Product Engineers and Data Engineers to gather any new data point or capture data changes. And combining them by working closely with various and growing business teams to capture requirements and convert them into business impact.\n\nWe are a tight-knit group made up of culinarista, netflix enthusiasts, readers, and amateur gamers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our Data Warehouse team is one of the key teams to bring data into critical information and knowledge that can be used to make sound business resolutions. We are hardening the bridges by working closely with Product Engineers and Data Engineers to gather any new data point or capture data changes. And combining them by working closely with various and growing business teams to capture requirements and convert them into business impact.</div><div><br></div><div>We are a tight-knit group made up of culinarista, netflix enthusiasts, readers, and amateur gamers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710917725702,"descriptionPlain":"About the Role\n\nAs a Data Warehouse Engineer, you’ll be an instrumental cog in the Data team that impacts the company’s analytical data infrastructure.\n\nYour main objective is to design, develop, and manage our data warehouse and the data infrastructure that supports it, which needs to operate reliably at scale using a high degree of automation in many aspects. You will also be managing the single source of truth of data for analytics and partnering with product managers, product engineers, data engineers, BI/analytics, and data scientists during this ride. You will also play active roles in ensuring data governance policies and tooling are implemented and adhered to.\n\nBest yet, you’ll have the opportunity to flex your technical and communication skills, helping the team to best utilize the data that we have and deliver beautifully simple and scalable solutions to meet user needs.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Data Warehouse Engineer, you’ll be an instrumental cog in the Data team that impacts the company’s analytical data infrastructure.</div><div><br></div><div>Your main objective is to design, develop, and manage our data warehouse and the data infrastructure that supports it, which needs to operate reliably at scale using a high degree of automation in many aspects. You will also be managing the single source of truth of data for analytics and partnering with product managers, product engineers, data engineers, BI/analytics, and data scientists during this ride. You will also play active roles in ensuring data governance policies and tooling are implemented and adhered to.</div><div><br></div><div>Best yet, you’ll have the opportunity to flex your technical and communication skills, helping the team to best utilize the data that we have and deliver beautifully simple and scalable solutions to meet user needs.</div><div><br></div>","id":"6be8c0fe-d1e1-416f-8b8c-19d792255ff4","lists":[{"text":"What You Will Do","content":"<li>Handle End to End Data Pipelines from heterogeneous input to Data Warehouse, serving various multiple teams for analytical purposes</li><li>Develop scalable automation/script to handle growing data warehouse tasks</li><li>Become a data architect by implementing Data Modeling concepts and data governance policies based on data type and use case</li><li>Diagnose and solve data issues in our data pipelines look for the root cause of problems and envision a long-term solution</li><li>Responsible for managing a reliable Single Version of Truth and turning Data into critical information and knowledge that can be used to make sound business resolutions</li><li>Work closely with the data stakeholders to come up with a working data solution and accommodate their data needs</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Consult with product and data engineers to ensure the developed data solutions match the business needs</li>"},{"text":"What You Will Need ","content":"<li>At least 2-3 years of experience in a Data Environment as a Data Warehouse Developer or Data Engineer</li><li>Deep knowledge related to Data Warehouse concepts, architecture, and data modeling</li><li>Advanced level SQL (Query, CRUD operation). Experience in cloud data warehouses (BigQuery, Redshift) is a plus</li><li>Enjoy writing code to solve any data problems, preferably in Python, and experience in Java and Go experiences is a plus</li><li>Experience in a range of ETL systems (Apache Airflow, Debezium, etc)</li><li>Basic knowledge in real-time data processing. Experience in Apache Kafka, and Apache Flink is a plus</li><li>Basic knowledge of containerization (Docker) and CI/CD (Gitlab CI)</li><li>Analytical and data-driven, you love digging into the data to know what’s happening and define &amp; measure success on every project</li>"}],"text":"Data Warehouse Engineer - Payments Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Data Warehouse Engineer, you’ll be an instrumental cog in the Data team that impacts the company’s analytical data infrastructure.</div><div><br></div><div>Your main objective is to design, develop, and manage our data warehouse and the data infrastructure that supports it, which needs to operate reliably at scale using a high degree of automation in many aspects. You will also be managing the single source of truth of data for analytics and partnering with product managers, product engineers, data engineers, BI/analytics, and data scientists during this ride. You will also play active roles in ensuring data governance policies and tooling are implemented and adhered to.</div><div><br></div><div>Best yet, you’ll have the opportunity to flex your technical and communication skills, helping the team to best utilize the data that we have and deliver beautifully simple and scalable solutions to meet user needs.</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a Data Warehouse Engineer, you’ll be an instrumental cog in the Data team that impacts the company’s analytical data infrastructure.\n\nYour main objective is to design, develop, and manage our data warehouse and the data infrastructure that supports it, which needs to operate reliably at scale using a high degree of automation in many aspects. You will also be managing the single source of truth of data for analytics and partnering with product managers, product engineers, data engineers, BI/analytics, and data scientists during this ride. You will also play active roles in ensuring data governance policies and tooling are implemented and adhered to.\n\nBest yet, you’ll have the opportunity to flex your technical and communication skills, helping the team to best utilize the data that we have and deliver beautifully simple and scalable solutions to meet user needs.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6be8c0fe-d1e1-416f-8b8c-19d792255ff4","applyUrl":"https://jobs.lever.co/GoToGroup/6be8c0fe-d1e1-416f-8b8c-19d792255ff4/apply"},{"additionalPlain":"About The Team\n\nOur Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. </div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1717127267953,"descriptionPlain":"About The Team\n\nAre you a digital marketing aficionado with a knack for driving results through advertising platforms? We're on the lookout for a savvy Digital Marketing Manager to lead our advertising efforts targeting merchants utilizing GoPay, Midtrans, and Moka platforms. If you're ready to harness the power of Google Ads, Meta Ads, TikTok Ads, and more to elevate merchant services, this role is for you.\n\nAs a Digital Marketing Manager for Merchant Services (Ads), you'll be at the forefront of revolutionizing how merchants engage with leading platforms like GoPay, Midtrans, and Moka. Join our team and spearhead innovative advertising campaigns that drive real impact and growth in the merchant services sector.\n","description":"<div><b>About The Team</b></div><div><br></div><div>Are you a digital marketing aficionado with a knack for driving results through advertising platforms? We're on the lookout for a savvy Digital Marketing Manager to lead our advertising efforts targeting merchants utilizing GoPay, Midtrans, and Moka platforms. If you're ready to harness the power of Google Ads, Meta Ads, TikTok Ads, and more to elevate merchant services, this role is for you.</div><div><br></div><div>As a Digital Marketing Manager for Merchant Services (Ads), you'll be at the forefront of revolutionizing how merchants engage with leading platforms like GoPay, Midtrans, and Moka. Join our team and spearhead innovative advertising campaigns that drive real impact and growth in the merchant services sector.</div>","id":"bc0944ec-775a-4a20-a55e-df5ddbbf4ff8","lists":[{"text":"What You Will Do","content":"<li>Ad Campaign Strategy: Devise and execute strategic advertising campaigns across Google Ads, Meta Ads (including Facebook and Instagram), TikTok Ads, and other relevant platforms to boost merchant acquisition and engagement</li><li>Performance Optimization: Monitor ad performance metrics closely, employing A/B testing and data analysis to optimize campaigns for maximum ROI and merchant conversion</li><li>Creative Ad Development: Collaborate with design and content teams to craft compelling ad creatives tailored to each platform and merchant audience, ensuring maximum impact and engagement</li><li>Budget Management: Efficiently manage advertising budgets across platforms, allocating resources effectively to achieve campaign objectives and KPIs</li><li>Audience Targeting: Utilize advanced targeting capabilities on advertising platforms to reach relevant merchant segments and drive qualified leads for merchant services</li><li>Ad Tech Mastery: Stay updated on the latest trends and best practices in ad tech, leveraging new features and innovations on platforms to stay ahead of the curve..</li>"},{"text":"What You Will Need","content":"<li>Minimum 3 years of hands-on experience managing digital advertising campaigns, with a focus on Google Ads, Meta Ads (Facebook/Instagram), and TikTok Ads</li><li>Proficient in data analysis and interpretation, with the ability to derive actionable insights from advertising performance metrics to inform campaign optimization strategies</li><li>Strong creative instincts and the ability to ideate and execute engaging ad creatives that resonate with merchant audiences across different platforms</li><li>Comfortable navigating ad management interfaces and tools provided by Google, Meta, TikTok, and other advertising platforms, with a knack for troubleshooting and problem-solving</li><li>Excellent communication and teamwork skills, with the ability to collaborate effectively with cross-functional teams including design, content, and product teams</li><li>Thrive in a fast-paced, ever-evolving environment, with the adaptability to quickly learn and implement new advertising techniques and strategies as platforms evolve</li><li>Native or near-native proficiency in Bahasa Indonesia is required to effectively communicate with local merchants and stakeholders</li>"}],"text":"Digital Marketing Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Team</b></div><div><br></div><div>Are you a digital marketing aficionado with a knack for driving results through advertising platforms? We're on the lookout for a savvy Digital Marketing Manager to lead our advertising efforts targeting merchants utilizing GoPay, Midtrans, and Moka platforms. If you're ready to harness the power of Google Ads, Meta Ads, TikTok Ads, and more to elevate merchant services, this role is for you.</div><div><br></div><div>As a Digital Marketing Manager for Merchant Services (Ads), you'll be at the forefront of revolutionizing how merchants engage with leading platforms like GoPay, Midtrans, and Moka. Join our team and spearhead innovative advertising campaigns that drive real impact and growth in the merchant services sector.</div>","descriptionBodyPlain":"About The Team\n\nAre you a digital marketing aficionado with a knack for driving results through advertising platforms? We're on the lookout for a savvy Digital Marketing Manager to lead our advertising efforts targeting merchants utilizing GoPay, Midtrans, and Moka platforms. If you're ready to harness the power of Google Ads, Meta Ads, TikTok Ads, and more to elevate merchant services, this role is for you.\n\nAs a Digital Marketing Manager for Merchant Services (Ads), you'll be at the forefront of revolutionizing how merchants engage with leading platforms like GoPay, Midtrans, and Moka. Join our team and spearhead innovative advertising campaigns that drive real impact and growth in the merchant services sector.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/bc0944ec-775a-4a20-a55e-df5ddbbf4ff8","applyUrl":"https://jobs.lever.co/GoToGroup/bc0944ec-775a-4a20-a55e-df5ddbbf4ff8/apply"},{"additionalPlain":"Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.\n","additional":"<div><span style=\"font-size: 10pt\">Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718963848611,"descriptionPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","description":"<div><span style=\"font-size: 9pt\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","id":"5d07cd21-8826-4de7-9ad4-15909a0c5c37","lists":[{"text":"What you will do","content":"<li>Devise and implement tailored digital marketing strategies for GoRide, GoCar, GoSend, and GoShop</li><li>Analyze market trends to identify growth opportunities and refine strategies accordingly</li><li>Collaborate cross-functionally to ensure alignment with business goals</li><li>Monitor and evaluate campaign performance to drive optimization</li><li>Stay updated on industry trends and technologies to drive innovation</li><li>Manage relationships with external partners and agencies to support initiatives</li><li>Contribute to overarching marketing strategies and brainstorming sessions.</li><div><br></div>"},{"text":"What you will need","content":"<li>3+ years of digital marketing experience</li><li>Proficiency in digital marketing tools and platforms such as Google Adwords, Meta, TikTok Ads, Google Analytics &amp; Data Studio/Looker</li><li>Strong analytical, communication, and problem-solving skills</li><li>Bachelor's degree in Marketing, Communications, or related field</li><li>Fluency in English. </li><div><br></div>"}],"text":"Digital Marketing Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","descriptionBodyPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37","applyUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710749746948,"description":"","descriptionPlain":"","id":"abeeede5-8126-4e1d-b4e4-c5b4afbff43c","lists":[{"text":"What you will do","content":"<li>Devise and implement tailored digital marketing strategies to shape the Gojek brand and drive user acquisition and growth</li><li>Analyze market trends to identify growth opportunities and refine strategies accordingly</li><li>Collaborate cross-functionally to ensure alignment with business goals</li><li>Monitor and evaluate campaign performance to drive optimization</li><li>Stay updated on industry trends and technologies to drive innovation</li><li>Manage relationships with external partners and agencies to support initiatives</li><li>Contribute to overarching marketing strategies and brainstorming sessions.</li>"},{"text":"What you will need","content":"<li>3+ years of digital marketing experience</li><li>Proficiency in digital marketing tools and platforms</li><li>Strong analytical, communication, and problem-solving skills</li><li>Bachelor's degree in Marketing, Communications, or related field</li><li>Fluency in English, (with Vietnamese proficiency a plus).</li>"}],"text":"Digital Performance Marketing Specialist Gojek","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/abeeede5-8126-4e1d-b4e4-c5b4afbff43c","applyUrl":"https://jobs.lever.co/GoToGroup/abeeede5-8126-4e1d-b4e4-c5b4afbff43c/apply"},{"additional":"","additionalPlain":"","categories":{"department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716604187900,"description":"","descriptionPlain":"","id":"471c9704-cd3d-4cc3-9ddb-36f64cfa787b","lists":[{"text":"What you will do:","content":"<li>Facilitate clear communication with stakeholders to understand project requirements and expectations.</li><li>Utilize data-driven approaches to identify, analyze, and resolve complex business challenges.</li><li>Translate ambiguous problem statements into well-defined analytical questions and hypotheses.</li><li>Independently design and implement analytical frameworks to address business needs and drive improvements.</li><li>Implement scalable monitoring solutions that require a very minimum manual intervention while ensuring data accuracy and reliability</li>"},{"text":"What you will need:","content":"<li>Strong project management skills to balance the statistical &amp; long term strategies and tactical needs from regional team in achieving the targets</li><li>Superb business sense to transform an ambiguous business or product problem into a well-scoped and impactful analysis&nbsp;</li><li>Ability to independently select and implement the correct statistical test to answer business questions.</li><li>Solid experience in handling analytical using SQL, including both DDL and DML.</li><li>Experienced with job schedulers tools like Airflow or DBT.</li><li>Ability to code for data analysis in Python, R, or similar languages is advantageous.</li>"}],"text":"Driver Strategy Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/471c9704-cd3d-4cc3-9ddb-36f64cfa787b","applyUrl":"https://jobs.lever.co/GoToGroup/471c9704-cd3d-4cc3-9ddb-36f64cfa787b/apply"},{"additionalPlain":"About Us\n\nWe are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nAlong with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1714628452648,"descriptionPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px\">&nbsp;</span></div><div><span style=\"font-size: 16px\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","id":"dfe98505-36d8-4467-aa36-df8599ab69d8","lists":[{"text":"What You Will Do","content":"<li>Assess and manage team performance through staff meetings, one on ones, and quarterly assessments</li><li>Mentor your engineers to ensure their growth and engagement in the team, evaluate team workload and develop a staffing plan, and assign projects and balance workload to ensure continuous delivery and higher predictability</li><li>Serve as primary interface to staffing team, creating job descriptions, identifying sources for candidates, conducting interviews and shepherding candidates through the process</li><li>Lead a team of Software Engineers focused on improving velocity and impact across Gojek’s diverse project areas and platforms</li><li>Become a partner to Product Managers on deciding vision, strategy and OKRs</li><li>Provide technical expertise throughout the product life cycle including design, implementation, and delivery of scalable build/test/release infrastructure</li>"},{"text":"What You Will Need","content":"<li>Having at least 8 years of relevant software development experience preferably with experience in data products, also at least 2 years of leading and mentoring an engineering team to success</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, TDD and Test Engineering, and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate dependency risks</li><li>Ability to review the code and ensure code maintainability as part of new product enhancements.</li>"},{"text":"Bonus Points If","content":"<li>Understanding in data modeling for data warehouse, relational database, and non-relational database</li><li>Understanding in batch and stream data pipeline; Beam, Flink, Spark</li>"}],"text":"Engineering Manager - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px;\">&nbsp;</span></div><div><span style=\"font-size: 16px;\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8","applyUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8/apply"},{"additionalPlain":"About The Team\n\nThe Financial  Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities, with OJK  as the regulator. As a Financial Services  Compliance team, we are obliged to ensure the adherence of business units to Financial Services  system regulations and at the same time to help ensure the business units are in a strategic position to execute all the business initiative. We are a close-knit team who love to solve problems, eat good food, and taking extra care for each other.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The Financial&nbsp; Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities, with OJK&nbsp; as the regulator. As a Financial Services&nbsp; Compliance team, we are obliged to ensure the adherence of business units to Financial Services&nbsp; system regulations and at the same time to help ensure the business units are in a strategic position to execute all the business initiative. We are a close-knit team who love to solve problems, eat good food, and taking extra care for each other.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Legal","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713511797674,"descriptionPlain":"About The Role\n\nThe Compliance and Regulatory Affairs Manager is a strategic role within GoTo Financial payments division. As a Senior member of the team, she/he will be expected to be the primary PiC to ensure the alignment of GoTo Financial Services esp P2P and consumer lending business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to make sure the entity fully complies with the regulation.\n","description":"<div><b>About The Role</b></div><div><br></div><div>The Compliance and Regulatory Affairs Manager is a strategic role within GoTo Financial payments division. As a Senior member of the team, she/he will be expected to be the primary PiC to ensure the alignment of GoTo Financial Services esp P2P and consumer lending business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to make sure the entity fully complies with the regulation.</div>","id":"da40c805-1fbd-4228-8059-b7729041021e","lists":[{"text":"What You Will Do","content":"<li>Responsible to Compliance and Regulatory Affairs matters in GoTo Financial&nbsp; P2P operations, which includes but not limited to business/product reporting and approval process with the regulators, compliance advisory to business unit, as well as regulatory assessment</li><li>Make sure that compliance is part of the process excellence within Goto Financial’s financial services business line.&nbsp;</li><li>Maintain the latest update of financial services regulations and&nbsp; provide/disseminate assessment on such regulations to the internal&nbsp; units in GoTo Financial</li><li>Be the substantive PiC of GoTo Financial in any external engagements with OJK, other regulators, industry associations and other external stakeholders</li><li>Giving continued support on the creation, standardization and implementation of P2P Compliance, policies, terms &amp; conditions, internal working procedures and standard operational guidelines;</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What You Will Need","content":"<li>Bachelor Degree in Law/ Economics/ Accounting/ Computer Science/ Engineer. Having a master’s degree would be an advantage.</li><li>Possess certifications in Risk Management/ IT Audit will be an advantage.</li><li>At least 5 years of mixed experience in the area of economic/ payments policy/ regulatory compliance and past working experience in Bank Indonesia/ Otoritas Jasa Keuangan will be an advantage.&nbsp;</li><li>Advanced level of spoken and written both in English and Indonesian language to, self-initiating as well as a team player who are putting the team best interest above individuals’ objective</li><li>Excellent analytical skills with the capacity of identifying all risks and proactively choosing the best solutions, sound judgment, and attention to details.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, include builds credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"FinServ Compliance Manager - #9918","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The Compliance and Regulatory Affairs Manager is a strategic role within GoTo Financial payments division. As a Senior member of the team, she/he will be expected to be the primary PiC to ensure the alignment of GoTo Financial Services esp P2P and consumer lending business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to make sure the entity fully complies with the regulation.</div>","descriptionBodyPlain":"About The Role\n\nThe Compliance and Regulatory Affairs Manager is a strategic role within GoTo Financial payments division. As a Senior member of the team, she/he will be expected to be the primary PiC to ensure the alignment of GoTo Financial Services esp P2P and consumer lending business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to make sure the entity fully complies with the regulation.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da40c805-1fbd-4228-8059-b7729041021e","applyUrl":"https://jobs.lever.co/GoToGroup/da40c805-1fbd-4228-8059-b7729041021e/apply"},{"additionalPlain":"About The Team\n\nBeing part of the ODS FP&A consolidation team, you will be responsible for regular business reporting, including the preparation of weekly / monthly performance reviews. The team is task orientated, with the focus on ensuring things get done and problems get solved. There will also be opportunities to work with various teams and learn from the organization. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Being part of the ODS FP&amp;A consolidation team, you will be responsible for regular business reporting, including the preparation of weekly / monthly performance reviews. The team is task orientated, with the focus on ensuring things get done and problems get solved. There will also be opportunities to work with various teams and learn from the organization.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Finance","location":"Jakarta","team":"FP&A","allLocations":["Jakarta"]},"createdAt":1716181186480,"descriptionPlain":"About The Role\n\nWe are seeking an FP&A (Financial Planning & Analysis) Consolidation Analyst for our On-Demand Services (ODS) vertical. In this role, your responsibility is to support the various management reporting processes (including but not limited to, Weekly/Monthly reviews, Rolling Forecast reviews, and various budget vs actual reviews). You will also be part of the team responsible for the annual budgeting process for ODS.\n\nYou will be challenged to provide a clear overview and analysis of the entire ODS P&L which consists of multiple Business Units (BUs). In this role, you will be working extensively with the ODS FP&A team to ensure that processes run smoothly and that reports are prepared on an accurate and timely basis.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking an FP&amp;A (Financial Planning &amp; Analysis) Consolidation Analyst for our On-Demand Services (ODS) vertical. In this role, your responsibility is to support the various management reporting processes (including but not limited to, Weekly/Monthly reviews, Rolling Forecast reviews, and various budget vs actual reviews). You will also be part of the team responsible for the annual budgeting process for ODS.</div><div><br></div><div>You will be challenged to provide a clear overview and analysis of the entire ODS P&amp;L which consists of multiple Business Units (BUs). In this role, you will be working extensively with the ODS FP&amp;A team to ensure that processes run smoothly and that reports are prepared on an accurate and timely basis.</div>","id":"111ec429-1fa8-43ef-a9bc-94ad60444ea9","lists":[{"text":"What You Will Do","content":"<li>Responsible for regular business reporting, including the preparation of weekly / monthly performance reviews. Key tasks include preparation of the presentation deck, including commentary and analysis, ensuring the respective Finance Business Partners (FBPs) provide their inputs into the preparation template</li><li>Develop and maintain any new ODS level reports that might be required by management</li><li>Developing and documenting new FP&amp;A processes and policies, as well as looking to improve existing processes</li><li>Working with various Product/Function FBPs to support Business Unit level analytics requirements</li><li>Ad hoc analytics as required to support management decision making</li><li>Budgeting and Forecasting: Support the annual budgeting process including any ad-hoc / quarterly revisions. Including but not limited to template preparation, briefing sessions, ensuring timelines are met and submission into the budget system.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Degree-level qualification in Accounting/ Business / Quantitative fields of study</li><li>3-5 years experience in Finance, preferably in FP&amp;A role for 1-3 years</li><li>Proficient in financial modeling, to be able to take a business requirement and build a financial model around it</li><li>Able to work independently with strong attention to detail</li><li>Able to communicate effectively with multiple stakeholders across various levels of seniority, both written and verbal</li><li>Able to translate business requirements into financial view and vice versa</li><li>Think critically and in a structured manner</li><li>Basic knowledge of data modeling, and experience with Google BigQuery is a big plus.</li>"}],"text":"FP&A - Consolidation Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking an FP&amp;A (Financial Planning &amp; Analysis) Consolidation Analyst for our On-Demand Services (ODS) vertical. In this role, your responsibility is to support the various management reporting processes (including but not limited to, Weekly/Monthly reviews, Rolling Forecast reviews, and various budget vs actual reviews). You will also be part of the team responsible for the annual budgeting process for ODS.</div><div><br></div><div>You will be challenged to provide a clear overview and analysis of the entire ODS P&amp;L which consists of multiple Business Units (BUs). In this role, you will be working extensively with the ODS FP&amp;A team to ensure that processes run smoothly and that reports are prepared on an accurate and timely basis.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking an FP&A (Financial Planning & Analysis) Consolidation Analyst for our On-Demand Services (ODS) vertical. In this role, your responsibility is to support the various management reporting processes (including but not limited to, Weekly/Monthly reviews, Rolling Forecast reviews, and various budget vs actual reviews). You will also be part of the team responsible for the annual budgeting process for ODS.\n\nYou will be challenged to provide a clear overview and analysis of the entire ODS P&L which consists of multiple Business Units (BUs). In this role, you will be working extensively with the ODS FP&A team to ensure that processes run smoothly and that reports are prepared on an accurate and timely basis.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/111ec429-1fa8-43ef-a9bc-94ad60444ea9","applyUrl":"https://jobs.lever.co/GoToGroup/111ec429-1fa8-43ef-a9bc-94ad60444ea9/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705377654170,"descriptionPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","id":"a3543985-6d2c-45cf-84f7-312ec7efed36","lists":[{"text":"What Will You Do","content":"<li>Write and deploy code that's clear, concise, performant, tested, and easy to understand by other teams and engineers</li><li>Participate in design reviews and own feature development from end to end</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices</li><li>Deep dive and debug production issues across services and levels of the stack when needed</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently</li>"},{"text":"What Will You Need","content":"<li>5+ years experience building consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Proficiency with one or more programming languages like Java, Go, and Kotlin.</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, asynchronous programming, fault tolerance and monitoring, performance, feature flags</li><li>Understanding how mobile/web applications interact with back-end and other systems. Experience in building frontend UIs is a bonus</li><li>Good understanding of SQL/NoSQL databases</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, GCP</li><li>Excellent verbal and written communication skills</li><div><br></div>"}],"text":"Full Stack Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","descriptionBodyPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36","applyUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1712032361628,"descriptionPlain":"Responsible for the growth and operations of overall Consumer Lending business in Tokopedia, which includes BNPL and Cash Loan.\nIn this role, you will work with the Tokopedia team in defining business opportunities, be hands-on in the execution of the initiatives, and work alongside the Product and Credit Risk team to enable growth levers. You are also expected to work with the Finance, Legal & Compliance team as check & balance of the initiatives that we do in alignment with OJK regulations.\n","description":"<div><span style=\"font-size: 10pt\">Responsible for the growth and operations of overall Consumer Lending business in Tokopedia, which includes BNPL and Cash </span><a href=\"http://Loan.In\" style=\"font-size: 10pt\" class=\"postings-link\">Loan.</a></div><div><a href=\"http://Loan.In\" style=\"font-size: 10pt\" class=\"postings-link\">In</a><span style=\"font-size: 10pt\"> this role, you will work with the Tokopedia team in defining business opportunities, be hands-on in the execution of the initiatives, and work alongside the Product and Credit Risk team to enable growth levers. You are also expected to work with the Finance, Legal &amp; Compliance team as check &amp; balance of the initiatives that we do in alignment with OJK regulations.</span></div>","id":"424140f5-5064-4ce2-8c4d-2b7ecbb14d51","lists":[{"text":"What you will do","content":"<li>Define growth initiatives that will create significant impact on transaction volume and user base, while at the same time helping increase LTV and retention of ecommerce users</li><li>Work closely with Tokopedia fintech team to execute initiatives, review performance, and propose improvements, such as voucher mechanics and communication channels</li><li>Work with the Product team to develop Product roadmap that will improve acquisition, engagement and retention of users</li><li>Collaborate with the Consumer Lending business teams for cross selling users to other use cases beyond ecommerce with LTV as main goalEngage with Finance, Legal and Compliance on any new major initiatives to ensure OJK compliance</li>"},{"text":"What you will need","content":"<li>&nbsp;Previous experience in ecommerce platform is a bonus</li><li>Good understanding of ecommerce business and lending products; has ability to articulate how lending products fit into an ecommerce ecosystem and their relevant use cases</li><li>Excellent collaborative skill and stakeholder management; has ability to engage people from different functions, culture and organizationsA self-starter</li>"}],"text":"Gopay Later Growth Senior Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Responsible for the growth and operations of overall Consumer Lending business in Tokopedia, which includes BNPL and Cash </span><a href=\"http://Loan.In\" style=\"font-size: 10pt;\" class=\"postings-link\" target=\"_blank\" rel=\"noopener noreferrer\">Loan.</a></div><div><a href=\"http://Loan.In\" style=\"font-size: 10pt;\" class=\"postings-link\" target=\"_blank\" rel=\"noopener noreferrer\">In</a><span style=\"font-size: 10pt;\"> this role, you will work with the Tokopedia team in defining business opportunities, be hands-on in the execution of the initiatives, and work alongside the Product and Credit Risk team to enable growth levers. You are also expected to work with the Finance, Legal &amp; Compliance team as check &amp; balance of the initiatives that we do in alignment with OJK regulations.</span></div>","descriptionBodyPlain":"Responsible for the growth and operations of overall Consumer Lending business in Tokopedia, which includes BNPL and Cash Loan.\nIn this role, you will work with the Tokopedia team in defining business opportunities, be hands-on in the execution of the initiatives, and work alongside the Product and Credit Risk team to enable growth levers. You are also expected to work with the Finance, Legal & Compliance team as check & balance of the initiatives that we do in alignment with OJK regulations.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/424140f5-5064-4ce2-8c4d-2b7ecbb14d51","applyUrl":"https://jobs.lever.co/GoToGroup/424140f5-5064-4ce2-8c4d-2b7ecbb14d51/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Internship","location":"Jakarta","allLocations":["Jakarta"]},"createdAt":1704877859106,"description":"","descriptionPlain":"","id":"ce6e4a7d-09a4-446e-b717-6232efaed996","lists":[{"text":"What you will do:","content":"<li><b>Insight- </b>Participate in brainstorming to produce insight based on research findings</li><li><b>Operations- </b>Support research activities planning, data recording, and data cleaning&nbsp;</li><li><b>Data collection - </b>Conduct interviews, surveys, FGDs, systematic search, and other methods.</li><li><b>Engagement - </b>Coordinate with Implementation Partners and stakeholders to ensure smooth coordination and execution</li>"},{"text":"What you will need: ","content":"<li>Final year student or fresh graduate in any major. Preferable S2 students majoring in anthropology, cultural studies, psychology, or other subjects with strong qualitative background.</li><li>Have experience in conducting end-to-end research projects from question formulation, data collection, analysis, and insight writing.</li><li>Have an understanding of basic quantitative and qualitative research methods</li><li>Has a vision and passion for community empowerment, economic development, and tackling environmental crises.&nbsp;Have a synthesizing ability and passion for developing this skill.</li><li>One year of experience in executing and monitoring the project. Has project management skills, including planning work, managing details, keeping multiple tasks/projects on track, using time well, and delivering results.</li><li>Strong verbal and written communication skills in both Bahasa Indonesia and English; other languages are a plus point.</li><li>Experience working in a cross-functional team and able to work in a fast-paced, technical environment.</li>"}],"text":"GoTo Impact Lab Research Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/ce6e4a7d-09a4-446e-b717-6232efaed996","applyUrl":"https://jobs.lever.co/GoToGroup/ce6e4a7d-09a4-446e-b717-6232efaed996/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</div><div>We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</div><div>Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718006842841,"descriptionPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","id":"7d1c915f-ac53-4a2c-887a-41bbbda48a26","lists":[{"text":"What You Will Do","content":"<li>Execute design tasks such as layout composition, image editing, typography, and color correction</li><li>Assist in the development of design concepts for various marketing collateral, including digital advertisements, print and digital materials, and more</li><li>Support the Art Director to provide visual assets for video and key visuals productions</li><li>Think creatively to generate visuals that connect with target audiences</li>"},{"text":"What You Will Need","content":"<li>A bachelor’s degree, with 3 years of experience in a related field</li><li>Proficiency in design software such as Adobe Creative Suite (Photoshop, Illustrator, and Premier), with a basic understanding of design principles and techniques</li><li>A portfolio showcasing examples of design work</li><li>Strong attention to detail and a passion for visual storytelling, with the ability to create compelling designs that resonate with the target audience</li><li>A can-do attitude with a determination to see tasks through to completion</li><li>Enthusiasm for design and a proactive attitude, with a desire to contribute ideas, and solve problems creatively</li>"}],"text":"Graphic Designer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","descriptionBodyPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26","applyUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"Fintech - Consumer Payments","location":"Jakarta","team":"Consumer Experience","allLocations":["Jakarta"]},"createdAt":1719204915336,"description":"","descriptionPlain":"","id":"00c9bdb6-623b-4604-8d87-aa0496bfc30e","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps, and actual customer insights</li><li>Drive actionable insights recommendations such as making funnel conversion analysis, cohort analysis, long-term trends, user segmentation, etc</li><li>Identify the business need and generate a hypothesis based on the business need to design &amp; run experiments</li><li>Build predictive model or clustering model to improve consumer incentive targeting effectiveness</li><li>Create and manage dashboards and data pipelines to monitor metrics to measure business performance</li><li>Working closely with the Business team and other data teams (Data Engineer, Data Science) to implement data solutions</li>"},{"text":"What You Will Need ","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 2 years of working experience in the data analytics field</li><li>Proficiency in data analysis tools and programming languages such as Python, R, SQL, and data visualization tools like Tableau, or Looker</li><li>Strong analytical skills to interpret complex data sets and extract actionable insights</li><li>High proficiency in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficient in Descriptive Analytics, Predictive Analytics, and Clustering analytics</li><li>Data Management: Familiarity with data collection, storage, and management best practices.&nbsp;Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li>"}],"text":"Growth Analyst - Consumer Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/00c9bdb6-623b-4604-8d87-aa0496bfc30e","applyUrl":"https://jobs.lever.co/GoToGroup/00c9bdb6-623b-4604-8d87-aa0496bfc30e/apply"},{"additionalPlain":"About the Team\n\nThe Financial Services stream at Gojek is passionate about empowering our users with the tools to be financially responsible. The Growth team is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Financial Services stream at Gojek is passionate about empowering our users with the tools to be financially responsible. The Growth team is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"Gojek GoPay","allLocations":["Jakarta"]},"createdAt":1705907656882,"descriptionPlain":"About the Role\n\nAs a Lead Growth Analyst on the Financial Services Platform, you will be responsible to utilize our voluminous data to improve acquisition, activation, retention, loyalty & cross selling for our Financial Services products across platforms within the ecosystem. You will be driving the analytics projects of the Growth team across different platforms, ultimately enabling the consumer lending business team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesian. You will be based in the Jakarta office.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Lead Growth Analyst on the Financial Services Platform, you will be responsible to utilize our voluminous data to improve acquisition, activation, retention, loyalty &amp; cross selling for our Financial Services products across platforms within the ecosystem. You will be driving the analytics projects of the Growth team across different platforms, ultimately enabling the consumer lending business team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesian. You will be based in the Jakarta office.</div><div><br></div>","id":"ac34e3be-5747-4371-ad39-4b61d62302ce","lists":[{"text":"What You Will Do","content":"<li>Lead the Growth Analytics team and drive prioritization, strategy, and focus on solutions to solve user problems across platforms. You will be collaborating with the Marketing team on a daily basis</li><li>Maintain rigor in analytical excellence in terms of data analytics, A/B test design, and appropriate statistical tests across the products</li><li>Liaise with other analytical chapters within the Financial Services Platform as well as across Gojek such as Data Science, Data Engineering, Data Governance, Risk Analytics, etc, to ensure that initiatives are aligned and data integrity standards are adhered to</li><li>Discover growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps, and actual customer insights</li><li>Analyze our complex and ever-growing data, present insights, and propose strategic options to senior management to drive business decisions</li><li>Test and validate solutions through a proper experimentation process.</li>"},{"text":"What You Will Need ","content":"<li>At least 3 years of working experience in an analytical role (data analyst / BI/data science/statistician, etc)</li><li>Strong SQL skills with expertise in either Excel/Python/R</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps</li><li>Experience in planning, designing, and executing experiments that can help business growth to increase upper funnel, customer retention, and cross-selling. Also comfortable working with frequentist statistics to analyze experiment results</li><li>Strong data viz and data storytelling skills</li><li>Strong project management skills to manage projects; able to work together with relevant units, also can manage and prioritize multiple internal stakeholders</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team.</li>"}],"text":"Growth Lead - GoPay Later","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Lead Growth Analyst on the Financial Services Platform, you will be responsible to utilize our voluminous data to improve acquisition, activation, retention, loyalty &amp; cross selling for our Financial Services products across platforms within the ecosystem. You will be driving the analytics projects of the Growth team across different platforms, ultimately enabling the consumer lending business team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesian. You will be based in the Jakarta office.</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a Lead Growth Analyst on the Financial Services Platform, you will be responsible to utilize our voluminous data to improve acquisition, activation, retention, loyalty & cross selling for our Financial Services products across platforms within the ecosystem. You will be driving the analytics projects of the Growth team across different platforms, ultimately enabling the consumer lending business team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesian. You will be based in the Jakarta office.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ac34e3be-5747-4371-ad39-4b61d62302ce","applyUrl":"https://jobs.lever.co/GoToGroup/ac34e3be-5747-4371-ad39-4b61d62302ce/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713765081862,"descriptionPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","description":"<div><span style=\"font-size: 10.5pt\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","id":"761415aa-89b7-4ffb-a19b-2b91ac4243b4","lists":[{"text":"What You Will Do","content":"<li>Lead the strategy and growth function for GoModal. You will be collaborating with the Marketing &amp; Product teams on a daily basis.</li><li>Maintain rigor in analytical excellence in terms of data analytics, A/B test design, and appropriate statistical tests across the product funnel from acquisition, adoption, retention to monetization.</li><li>Discover growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps and actual customer insights.</li><li>Analyze our complex and ever-growing data, present insights, and propose strategic options to management to drive business decisions.</li><li>Test and validate solutions through proper experimentation process.</li><li>Importantly, using data to identify growth opportunities and problem solve so as to achieve business goals with metrics such as conversion rates of WL to submit KYC, adoption rate &amp; GTV (disbursement)</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 4 years of working experience in a growth or product role (growth marketing, data analyst, BI, strategy, etc).</li><li>Strong project management skill to manage complex projects; also can manage and prioritize multiple internal and external stakeholders.</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps.</li><li>Experienced planning, designing, and executing experiments. Also comfortable working with frequentist statistics to analyze experiment results.</li><li>Strong data visualization and data storytelling skills.</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team.</li><li>Preferred but not required: Strong SQL skills with expertise in either Excel/Python/R&nbsp;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Growth Lead (Merchant Lending)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","descriptionBodyPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4","applyUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714985249008,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","id":"2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Introduce beneficial business changes through well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve the business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resourcesProactively improve the operation process in the team and act on how to drive a faster, more effective, and efficient execution process through third-party tools or in-house service</li>"},{"text":"What You Will Need ","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience&nbsp;</li><li>Data analytics capability, have a good knowledge of SQL and experimentation processes; High Proficiency in Python and R is a plus</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Planning & Operation - GoFood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","applyUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e/apply"},{"additionalPlain":"About the Team \n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717479647909,"descriptionPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","id":"1fad1d82-dc7b-4d5a-b0d0-eb4678350242","lists":[{"text":"What You Will Do","content":"<li>Lead and Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Work closely with the Product, Marketing, Sales, Research, and Intelligence teams to understand merchant pain points and define the solution as well as Data, Ads, and Operation teams in the development and implementation of initiatives and strategies</li><li>Prepare reports of key merchant metrics analysis as a basis of rationale and recommendations to upper management, including CxOs of Gojek and GoTo Group</li><li>Conduct competitive benchmarking and analysis with local and international counterparts</li><li>Introduce beneficial business changes through a well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience</li><li>Strong critical thinking, coordination, and stakeholder management skills to drive analysis and cross-collaboration independently</li><li>Data analytics capability have a good knowledge of SQL and experimentation process; High Proficiency in Python and R is a plus</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also being a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Strategy Manager - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","descriptionBodyPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242","applyUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719458638459,"descriptionPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","description":"<div><span style=\"font-size: 10pt\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","id":"b68a9eb5-f615-441a-b04c-2d2c6a9d4703","lists":[{"text":"What You Will Do","content":"<li>Perform development and review of Business Continuity Management Framework and its supporting policies;</li><li>Strategize, coordinate, and provide challenge and advisory in the implementation of Business Continuity Programs such as BCP, BCP testing, Crisis Management exercise, and ways of integrating Business Continuity concept and awareness in the operational of business and support functions;</li><li>Respond to audit and regulatory requirements on BCM;</li><li>Design and deliver BCM communications and clinic sessions;</li><li>Provide Business Continuity update report to Management</li><li>Facilitate and support the execution of the plans at the time of a crisis event.</li>"},{"text":"What You Will Need","content":"<li>Minimum bachelor’s degree in relevant discipline from a reputable university</li><li>Minimum 8 years of Business Continuity Management experience in prominent consulting firms and/or multinational companies</li><li>Growth mindset, analytical, assertive and good interpersonal skill</li><li>Relevant BCM certifications&nbsp;</li><li>Good competency in English, verbal and written.</li>"}],"text":"Head of Business Continuity Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","descriptionBodyPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703","applyUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703/apply"},{"additionalPlain":"Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717651947726,"descriptionPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><span style=\"font-size: 16px\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"c838dc08-24e8-417c-9d70-a617bc58e200","lists":[{"text":"Responsibilities","content":"<li>Gojek is looking for an experienced technologist with a passion &amp; understanding of technology to lead its transportation product. Transport is one of the flagship products in GOJEK superapp. It is launched in Indonesia, Singapore and Vietnam.</li><div><br></div><li>As Head of Engineering of Transport, you will partner with GOJEK VP, Senior VP of technology, Transport Head of Business, Group Product Manager and other business stakeholders in the company to formulate a business strategy for Transport. You will work closely with PMs and Tech Leads in Transport to realize this strategy to make GOJEK a dominant player in markets.</li><div><br></div><li>Strategic thinking and strong business acumen along with deep technical expertise are essential in this role. We expect you to be well-versed in current technological trends and familiar with a variety of business concepts. If you are also an excellent communicator and public speaker, we’d like to meet you.</li><div><br></div><div>What you will do</div><div><br></div><li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Setup growth paths for the team and engage them in processes and practices that shall help scale engineering</li><li>Collaborate with cross functional teams and stakeholders (Business, Product, Data, UX, Platform, Devops etc.) to unlock the next phase of business growth.</li><li>Provide technology leadership to the team and foster engineering excellence.</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"Experience and Skills","content":"<li>Should have at least 9 years of hands-on experience in designing, developing, testing and deploying applications at scale.</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus.</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation.</li><li>Experience as people manager and passionate towards building and growing a high functioning team.&nbsp;</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions.</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities.</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Head of Engineering - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px;\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px;\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px;\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px;\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200","applyUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200/apply"},{"additionalPlain":"About The Team\n\nYou will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><br></div><div><span style=\"font-size: 14px\">You will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718871657577,"descriptionPlain":"Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","description":"<div><span style=\"font-size: 14px\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","id":"6dc20c4e-4d40-4f57-a138-4776013e454e","lists":[{"text":"What You Will Do","content":"<li>Oversee CS, Telesales, KYC, collection and FI team and Ops projects for our BNPL and cashloan product.&nbsp;</li><li>Develop &amp; Optimize Processes - Scale new and existing processes to allow the business to efficiently operate in Indonesia</li><li>Analytics - Analysis and tracking of onboarding, merchant experience and technical issues, risk management etc</li><li>Strategy - Choose which projects to prioritize, and set a timeline to reach goals quickly</li><li>Tool Improvements - Proactively search for new tools or ways which could improve a seamless support and setup experience, for both, merchant and buyer</li><li>Be fast, resourceful, and take initiative - Take ownership of regional commerce operations and do everything you can to support and enhance the quality of our services</li>"},{"text":"What This Role Needs","content":"<li>Min. 7 years experience in tech startup/fintech industry</li><li>Experience in operations strategy, sales strategy and product management is a big plus</li><li>Proven success in dynamic and complex environments, with a proven ability to rally teams and influence at all levels</li><li>Deep analytical skills, with high capacity to think strategically about complex issues, evaluate alternatives, and make compelling recommendations based on proven business case analysis</li><li>Outstanding communication skills, both verbal and written</li><li>Ability to lead complex and strategic initiatives and communicate effectively with technical teams</li><li>Ability to collaborate with various departments by utilizing superior relationship-building skills, interpersonal skills, and influence</li>"}],"text":"Head of Operation - Consumer Lending - #10162","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 14px;\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","descriptionBodyPlain":"Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e","applyUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e/apply"},{"additionalPlain":"About The Team\n\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><br></div><div><span style=\"font-size: 14px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705905810213,"descriptionPlain":"The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","description":"<div><span style=\"font-size: 14px\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 14px\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","id":"70493d8a-7d7f-4660-b1ed-c792d0d765be","lists":[{"text":"What You Will Do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What This Role Needs","content":"<li>At least 15 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Experienced in managing a huge team size</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closingExcellent in contract and commercial negotiation process</li><li>Experience in payment industry is a plus</li>"}],"text":"Head of Sales - Midtrans - #9618","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 14px;\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 14px;\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","descriptionBodyPlain":"The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be","applyUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be/apply"},{"additionalPlain":"Joining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>Joining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713930486899,"descriptionPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a  crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a  crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","id":"36caef5f-7a1c-4326-80b4-8c146060ac70","lists":[{"text":"What You Will Do","content":"<li>Develop and maintaining IT policies, standards and procedures according to applicable internal and external requirements, including the applicable regulations in Indonesia an other countries where GTF operate;</li><li>Develop and maintain compliance, governance and risk-related IT and business process flow;</li><li>Coordinating with compliance team to ensure that every initiative, development and collaboration are comply with the standards and regulations (internal and external);</li><li>Conduct routine evaluation of policies and procedures implementation and ensure best practice risk mitigation and assessment functions are maintained to comply with the company's strategy;</li><li>Coordinate with related IT work units to follow up on data requests and internal audit findings, external audits and regulators;</li><li>Develop the process and conduct the activities to safekeep or archive of every IT development document in a regular basis;</li><li>Implementing a good governance organization using the ISO27001, ISO 27701, PCI DSS framework and other relevant Technology &amp; Security best practices;</li><li>Develop and implement the RBAC and least privilege of access management in the GTF technology stack</li><li>Act as a Subject Matter Expert to the stakeholders and provide relevant &amp; applicable consultation for addressing the IT GRC requirement in lending product &amp; services.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years experiences as Information Security, IT Governance, Risk and Compliance (IT GRC) or IT Auditors;</li><li>Demonstrate excellent communication and writing skills and proficient with English written and spoken</li><li>Experienced in developing and maintaining IT and/or information security policies and procedures;</li><li>Excellent knowledge in developing risk management and IT framework, BIA, BCP and BCM Framework</li><li>Experienced in report document development and delivery;</li><li>Experienced in dealing with regulatory audit to represent the organization IT GRC operations;</li><li>Having good knowledge with local and regional payment &amp;&nbsp; lending regulatory requirements and how they impact IT policies (having experience is preferred);</li><li>Having excellent experience with ISO 27001, ITIL. COBIT, and PCI-DSS standards;</li><li>One or more of the following or equivalent certifications preferred: CISA, CRISC, ITIL, COBIT is preferred</li>"}],"text":"IT GRC Senior Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a  crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","descriptionBodyPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a  crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70","applyUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715584452832,"descriptionPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","description":"<div><b style=\"font-size: 16px\">About the team:</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","id":"d6ac496c-e0ad-4669-b594-ede9bf8d55f9","lists":[{"text":"What you will do:","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed,</li><li>Resolve account issues and complaints,</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis,</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments,</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation,</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients,</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms.</li>"},{"text":"What you will need:","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area,</li><li>A minimum of 3 years of experience in business management, sales, or project management is mandatory. </li><li>Prior experience in e-commerce and managing key accounts will be a plus point,</li><li>Fluency in both Bahasa and English is required,Able to multitask, prioritize, and manage time efficiently,</li><li>Ability to negotiate, persuade and influence others,</li><li>Excellent interpersonal, communication, presentation and analytical skills,</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills,</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners.</li>"}],"text":"Key Account Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the team:</b></div><div><span style=\"font-size: 16px;\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","descriptionBodyPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9","applyUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9/apply"},{"additionalPlain":"About The Team\n\nJoin the GoPay team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone has access to high quality financial services. If you have the curiosity, passion for technology, and collaborative spirit work with us and let's solve the problems with technology.\n","additional":"<div>About The Team</div><div><br></div><div>Join the GoPay team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone has access to high quality financial services. If you have the curiosity, passion for technology, and collaborative spirit work with us and let's solve the problems with technology.</div>","categories":{"department":"Fintech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717645977534,"descriptionPlain":"About The Role\n\nSince the launch of the GoPay app in 2023, we have seen exponential growth. Having said that , we have set even higher goals for ourselves. As part of the growth team in Consumer experience, you will be responsible for scaling GoPay app acquisition across all our acquisition channels. You will be working with the Growth Business teams, digital marketing, brand team, CRM team, and engineering teams to create a strategy around user acquisition and execution of the same. You will be expected to optimize existing channels of acquisition as well as identify new channels and user segments. Having prior experience in growing consumer products, the ability to apply user insights and data-driven decision-making will be considered highly relevant for this role. \n","description":"<div><b>About The Role</b></div><div><br></div><div>Since the launch of the GoPay app in 2023, we have seen exponential growth. Having said that , we have set even higher goals for ourselves. As part of the growth team in Consumer experience, you will be responsible for scaling GoPay app acquisition across all our acquisition channels. You will be working with the Growth Business teams, digital marketing, brand team, CRM team, and engineering teams to create a strategy around user acquisition and execution of the same. You will be expected to optimize existing channels of acquisition as well as identify new channels and user segments. Having prior experience in growing consumer products, the ability to apply user insights and data-driven decision-making will be considered highly relevant for this role.&nbsp;</div>","id":"4d916963-ca3f-406b-be57-a79e2e226904","lists":[{"text":"What You Will Do","content":"<li>Developing and Implementing a user insights &amp; data-driven product strategy that aligns with the overall GoPay business objectives</li><li>Own and define the ideas for building a growth platform that leverages organic and non-organic levers to acquire and activate users</li><li>Collaborate with business and marketing teams to monitor performance metrics, assess the effectiveness of strategies and drive continuous growth</li><li>Be on top of the execution of product and business initiatives</li><li>Work with Engineering on prioritizing the product initiatives and managing the roadmap deliverables</li><li>Define precise and well-scoped requirements documents that are easily understood by technical and non-technical audiences</li><li>Leverage user research, usability studies, market research, experiments, and data analysis and translate them into requirements that solve real problems for a large set of users; partner with design/research team to facilitate problem-solving/co-design sessions</li><li>Always be on top of market and regulatory trends, as well as the competitive landscape in the fintech industry</li>"},{"text":"What You Will Need","content":"<li>A Bachelor’s or Master’s degree (or an equivalent degree), preferably in engineering or management</li><li>Should have at least 5-6 years of working experience, working in tech or financial service companies is a plus.</li><li>Experience working with cross-functional teams and stakeholders (e.g., UX, Engineering, Marketing, Operations)</li><li>Passion for building high-quality user experiences and a commitment to product excellence</li><li>An analytical, data-driven, quantitative mindset; a love for digging into data to understand what’s happening and to define &amp; measure success on every project, with the ability to use data and metrics to justify requirements and features</li><li>Capable of understanding technical aspects and have successfully done so previously - showcasing not only strong planning skills but also technical experience</li><li>Ability to collaborate with agile product development teams and excitement about identifying new ways to help your team be more effective</li><li>Excellent communication skills with the ability to weave strategy, insights, priorities, and plans forward into a structured and organized storyline at all levels of management</li>"}],"salaryDescription":"<div><br></div><div><br></div>","salaryDescriptionPlain":"\n\n","text":"Lead Product Manager - Consumer Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Since the launch of the GoPay app in 2023, we have seen exponential growth. Having said that , we have set even higher goals for ourselves. As part of the growth team in Consumer experience, you will be responsible for scaling GoPay app acquisition across all our acquisition channels. You will be working with the Growth Business teams, digital marketing, brand team, CRM team, and engineering teams to create a strategy around user acquisition and execution of the same. You will be expected to optimize existing channels of acquisition as well as identify new channels and user segments. Having prior experience in growing consumer products, the ability to apply user insights and data-driven decision-making will be considered highly relevant for this role.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nSince the launch of the GoPay app in 2023, we have seen exponential growth. Having said that , we have set even higher goals for ourselves. As part of the growth team in Consumer experience, you will be responsible for scaling GoPay app acquisition across all our acquisition channels. You will be working with the Growth Business teams, digital marketing, brand team, CRM team, and engineering teams to create a strategy around user acquisition and execution of the same. You will be expected to optimize existing channels of acquisition as well as identify new channels and user segments. Having prior experience in growing consumer products, the ability to apply user insights and data-driven decision-making will be considered highly relevant for this role. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/4d916963-ca3f-406b-be57-a79e2e226904","applyUrl":"https://jobs.lever.co/GoToGroup/4d916963-ca3f-406b-be57-a79e2e226904/apply"},{"additionalPlain":"About the Team\n\nThe GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.</div>","categories":{"commitment":"Permanent","department":"ODS - Transport & Mobility","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718255937171,"descriptionPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","id":"8bf17375-6318-400f-8216-4a132071777a","lists":[{"text":"What You Will Do","content":"<li>Roadmapping → Establish strategic objectives, roadmap and timelines to guide the development and enhancement of the GoCorp platform</li><li>Focus on optimizing the client experience, ensuring the platform meets and exceeds user needs and expectations. Execute with precision make sure products and features are launched in timely manner</li><li>Seek product ideas and feedback based on both quantitative and qualitative date, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that one size doesn’t fit all and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Work closely with business, sales, and marketing teams to align product strategies and objectives. Ensuring the all teams runs with the same drumbeat&nbsp;</li><li>Ensure seamless coordination with other product teams connected to the GoCorp platform to maintain a cohesive product ecosystem</li>"},{"text":"What You Will Need","content":"<li>Proven experience if min 5-6 years in product management, preferably within a tech or platform-based company and B2B product</li><li>Strong strategic thinking and planning skills with the ability to set and achieve the mid term and long-term objectives</li><li>Data oriented – demonstrated an ability to balance between quantitative and qualitative data to optimize client experience.</li><li>Exceptional problem-solving skills with a proactive approach to overcoming challenges</li><li>Excellent collaboration skills with experience working across multiple departments</li><li>Proficiency in managing the entire product lifecycle, from concept to launch and beyond</li><li>Strong communication skills to articulate product vision and objectives effectively to diverse stakeholders</li><li>Solid understanding of the technical aspects of platform development and integration.</li><li>Fluent in written and verbal english</li>"}],"text":"Lead Product Manager, GoCorp","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a","applyUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1716776042348,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"4a126665-42d6-4a36-82a5-089dca789f41","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Nurturing &amp; mentoring 5-7 engineers members</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize their ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 7-8+ years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Leadership experience in leading a distributed team of software engineers</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>Working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, xgboost, Keras</li><li>Prior experience with cloud provider (GCP is a plus)</li>"}],"text":"Lead Software Engineer - Data Science Platform","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41","applyUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41/apply"},{"additionalPlain":"About the Team :\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n\n\n","additional":"<div>About the Team :</div><div><br></div><div>GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1715763990572,"descriptionPlain":"About the role :\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers GoFood .The Product and Operations team will be your companions on this ride. As a member of the GoFood team, you will be building experiences for GoFood's Users. \n\n\n\n","description":"<div>About the role :</div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers GoFood .The Product and Operations team will be your companions on this ride.&nbsp;As a member of the GoFood team, you will be building experiences for GoFood's Users.&nbsp;</div><div><br></div><div><br></div><div><br></div>","id":"b1f917e0-a9a0-4a3c-a4c3-505e41c1f034","lists":[{"text":"What You Will Do","content":"<li>Be responsible for the overall solution architecture of the products/services that you will be working on</li><li>Code, Design, prototype, perform reviews and consult in the process of building highly scalable, reliable, and fault-tolerant systems</li><li>As our senior technologist continuously refactor applications and architectures to maintain high-quality levels, be actively involved in formulating product roadmap and defining the OKRs of the team</li><li>Continue to stay abreast of the latest technologies in distributed systems, caching and research new technologies, tools that enable building the next generation systems</li><li>Act as an engineer that enjoys writing readable, concise, reusable, extensible code every day</li><li>Discuss, articulate requirements with product management and scope,&nbsp;</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 8 years of hands-on experience in designing, developing, testing, and deploying large scale applications, microservices in any language or stack (preferably golang)</li><li>At least 1 year of experience in leading a team of engineers</li><li>Good skill in design, development, testing and deploying applications on Golang or Erlang or Ruby or Java large-scale applications</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Excellent attitude and passion working in a team with willingness to learn</li><li>Able to collaborate well with multiple stakeholders in parallel to align &amp; unblock the team</li><li>Experience in building low latency, high volume REST API requests handling</li><li>Experience in working with relational databases (like postgres)</li><div><br></div>"}],"text":"Lead Software Engineer - Gofood","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the role :</div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers GoFood .The Product and Operations team will be your companions on this ride.&nbsp;As a member of the GoFood team, you will be building experiences for GoFood's Users.&nbsp;</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the role :\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers GoFood .The Product and Operations team will be your companions on this ride. As a member of the GoFood team, you will be building experiences for GoFood's Users. \n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/b1f917e0-a9a0-4a3c-a4c3-505e41c1f034","applyUrl":"https://jobs.lever.co/GoToGroup/b1f917e0-a9a0-4a3c-a4c3-505e41c1f034/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. \n\nAt the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. </div><div><br></div><div>At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</div><div><br></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1711535878605,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","id":"3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems</li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure</li><li>Enhance code quality and product performance through continuous improvement and innovation</li><li>Collaborate and communicate effectively with teams across multiple geographies</li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves</li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in working with end to end Observability stack. Hands on experience in building and managing the telemetry pipeline at large scale</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with Grafana stack, Cortex, SLI/SLO platforms is a plus</li><li>Prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Observability","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","applyUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710229189158,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nYou will take the wheel in building, operating, and maintaining our developer platform called GoPay.sh - empowering our entire engineering team with scale and extensibility in mind. With this team, you will be presented with ample opportunities to tackle challenging problems. Your efforts will directly improve the productivity of our engineers, and contribute to redefining the payments ecosystem in Indonesia, bringing wider and more inclusive financial services to the region and beyond.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">You will take the wheel in building, operating, and maintaining our developer platform called </span><a href=\"http://GoPay.sh\" style=\"font-size: 10pt\" class=\"postings-link\">GoPay.sh</a><span style=\"font-size: 10pt\"> - empowering our entire engineering team with scale and extensibility in mind. With this team, you will be presented with ample opportunities to tackle challenging problems. Your efforts will directly improve the productivity of our engineers, and contribute to redefining the payments ecosystem in Indonesia, bringing wider and more inclusive financial services to the region and beyond.</span></div>","id":"c3a0c7d8-a6e7-45a0-af1a-1eb5b6e18fc5","lists":[{"text":"What You Will Do","content":"<li>Translate our product’s goals into iterative MVPs, evaluate, and then refactor into a scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals, and improvements to code quality across the team</li><li>Design and develop highly scalable, highly available, reliable, secure, and fault-tolerant systems with minimal guidance</li><li>Collaborate with cross-functional teams (Product, DevOps, UX, Data Engineering, QA, etc) on planning and execution</li><li>Manage automated build/test/deployment environments</li><li>Continuously discover, evaluate, and implement new technologies to maximize development</li><li>Deploy, monitor, maintain, and fix products currently in production</li>"},{"text":"What You Will Need","content":"<li>At least 6+ years of relevant software development experience in designing, developing, testing, and deploying applications for large-scale applications</li><li>Deep understanding of Microservices (HTTP &amp; GRPC), and programming languages like Java, Golang, Ruby, and Clojure (and a willingness to learn others)</li><li>Experience with Spring Boot or Hibernate is a big plus</li><li>Experience with cryptography (PKI &amp; HSM) is a big plus</li><li>Experience with Postgresql, Kafka, Kubernetes, GCP &amp; DevOps: Gitlab CI, Terraform</li><li>Proficiency in OOP, SQL, and Design Patterns; experience with functional programming is a plus</li><li>Strong data modeling experience in Relational and NoSQL databases</li><li>Ability to implement Continuous Integration and Continuous Delivery; well-versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Ability to design and implement low-latency RESTful/GRPC services</li>"}],"text":"Lead Software Engineer - Payments Data Products & Infra","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt;\">You will take the wheel in building, operating, and maintaining our developer platform called </span><a href=\"http://GoPay.sh\" style=\"font-size: 10pt;\" class=\"postings-link\" target=\"_blank\" rel=\"noopener noreferrer\">GoPay.sh</a><span style=\"font-size: 10pt;\"> - empowering our entire engineering team with scale and extensibility in mind. With this team, you will be presented with ample opportunities to tackle challenging problems. Your efforts will directly improve the productivity of our engineers, and contribute to redefining the payments ecosystem in Indonesia, bringing wider and more inclusive financial services to the region and beyond.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nYou will take the wheel in building, operating, and maintaining our developer platform called GoPay.sh - empowering our entire engineering team with scale and extensibility in mind. With this team, you will be presented with ample opportunities to tackle challenging problems. Your efforts will directly improve the productivity of our engineers, and contribute to redefining the payments ecosystem in Indonesia, bringing wider and more inclusive financial services to the region and beyond.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c3a0c7d8-a6e7-45a0-af1a-1eb5b6e18fc5","applyUrl":"https://jobs.lever.co/GoToGroup/c3a0c7d8-a6e7-45a0-af1a-1eb5b6e18fc5/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1704273923584,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","id":"2d3aae20-ff7e-4afb-8164-a351661c1680","lists":[{"text":"What You Will Do ","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest-growing company in the transportation industry&nbsp;</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Partner with the product management team to define and execute the feature roadmapCoordinate with cross-functional teams (Mobile, DevOps, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building the next generation of Gojek services</li>"},{"text":"What You Will Need ","content":"<li>Should have at least 6 years of hands-on experience in designing, developing, testing and deploying applications on Java or Go for large scale applications</li><li>Proficient in System Design, OOP, SQL, Linux/Unix, and Design Patterns. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities, through self-discovery or by vouching for exploratory tasks</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Lead Software Engineer (IC) - Go-Food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680","applyUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713944910535,"descriptionPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","id":"cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Proactively establish and strengthen relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia.</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals.</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors.</li><li>Project Leadership: Lead multiple projects in partnership with government institutions, focusing on Tech and the Digital Economy.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances.</li><li>Project Management: Oversee public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred.</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government.</li><li>Established network among government stakeholders with a proven impact on policy decisions.</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Manager of Food & Groceries Regulatory","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","applyUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5/apply"},{"additionalPlain":"About The Team\n\nOur Marketing team is a part of the GoFood Business team based in Jakarta. The team consists of growth marketing, brand managers, brand executives, marketing analytics, and more. They are the magicians who combine logic and magic to create a brand that people love. Our main responsibility is to develop GoFood’s marketing campaign that ensures GoFood continuous growth. Making sure everyone knows, always thinks about GoFood and we also want everyone to stick with GoFood. More importantly, we want to deliver joy in the life of our consumer through the assortment, recommendation & rewards in our platform. We are also a data-driven team who strive to continuously improve our efficiency.\n\nCurrently, our team has been working on a lot of innovation, branding and promotional campaigns, which will help GoFood maintain our leadership in the market.\n\nGoFood Marketing team believes the growth of the business is driven by the growth of the talents. Of course we care about the business number, yet we also care about each other’s well-being and growth journey. Other than enjoying finding that “a-ha!” moments when swimming through the sea of data, our family also enjoys bonding over food, watching TV shows or sharing our hobbies.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing team is a part of the GoFood Business team based in Jakarta. The team consists of growth marketing, brand managers, brand executives, marketing analytics, and more. They are the magicians who combine logic and magic to create a brand that people love. Our main responsibility is to develop GoFood’s marketing campaign that ensures GoFood continuous growth. Making sure everyone knows, always thinks about GoFood and we also want everyone to stick with GoFood. More importantly, we want to deliver joy in the life of our consumer through the assortment, recommendation &amp; rewards in our platform. We are also a data-driven team who strive to continuously improve our efficiency.</div><div><br></div><div>Currently, our team has been working on a lot of innovation, branding and promotional campaigns, which will help GoFood maintain our leadership in the market.</div><div><br></div><div>GoFood Marketing team believes the growth of the business is driven by the growth of the talents. Of course we care about the business number, yet we also care about each other’s well-being and growth journey. Other than enjoying finding that “a-ha!” moments when swimming through the sea of data, our family also enjoys bonding over food, watching TV shows or sharing our hobbies.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707726960069,"description":"","descriptionPlain":"","id":"8d38e7a3-89eb-4d80-997d-b08404b0e1a0","lists":[{"text":"What You Will Do","content":"<li>Create analytics and insight generation initiatives by understanding the behavior, usage, and attitude of the customer towards the products in order to generate market insight, define opportunities, and drive growth</li><li>Craft and implement all consolidated campaign and business reporting requirements to monitor GoFood's performance through strong collaboration with key stakeholders</li><li>Present a holistic view on market and competitive insights to allow effective and strategic decision-making process</li><li>Discover GoFood consumers’ in-app and transaction behavior, and provide actionable insights and strategies to reach target acquisitions and monthly transacting users</li><li>Conduct GoFood consumer research initiatives, including consumer segmentation and movement tracking</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree from reputable universities or equivalent practical experience</li><li>1-3 years of experience working as a data analyst, business intelligence analyst, or growth analyst in technology, FMCG, start-up, or telecommunication industry</li><li>Must be highly proficient in analytical tools such as Excel, SQL, Google Data Studio. Python is a plus.</li><li>Ability to translate complex ideas into simple and intuitive communication, and balance deep analytical rigor with actionable insights</li><li>Strong understanding of marketing and analytical concepts such as segmentation, customer lifecycle, retargeting, attribution models, prediction, and A/B testing</li><li>Experience preparing and developing a campaign report or various complex business reports</li><li>Experience developing user segmentation and executing user nudging and CRM or Digital Marketing campaigns</li>"}],"text":"Marketing Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/8d38e7a3-89eb-4d80-997d-b08404b0e1a0","applyUrl":"https://jobs.lever.co/GoToGroup/8d38e7a3-89eb-4d80-997d-b08404b0e1a0/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713245102772,"descriptionPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","description":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","id":"3f4f687f-8599-4d5c-96d5-8af234c3b09d","lists":[{"text":"What You Will Do","content":"<li>Identify and define business opportunities that aligns with the overall merchant services business objectives</li><li>Translate business opportunities into a fit problem statement and able to measure the priority of the problem&nbsp;</li><li>Collaborate with Product Team to develop a merchant focused product in onboarding and support&nbsp;</li><li>Develop Go-To Market plan and oversee the product adoption from funnel conversion rates and merchant experiences during the process.&nbsp;</li><li>Monitoring the product life cycle and continuously improved the product with a data driven decision making process</li><li>Engaged sales and ops team to deliver the best onboarding and support experience for merchants</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of working experience, experience in product and project management is a plus.&nbsp;</li><li>Possess a strong sense of agency in navigating and creating clarity in ambiguous situations.</li><li>Ability to break down complex problems, identify use cases and solutions, and thrive in unstructured environments.</li><li>Comprehensive understanding of data, design, research, and business processes, with the ability to effectively collaborate with diverse teams.</li><li>Strong analytical and quantitative skills, with the capability to utilize data and metrics to support requirements and features.</li><li>Effective communication skills to articulate strategy, insights, priorities, and plans coherently to all levels of management.</li><li>Meticulous attention to detail, with a commitment to upholding high standards and managing multiple, competing priorities concurrently with minimal supervision.</li>"}],"text":"Onboarding & Support Business Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","descriptionBodyPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d","applyUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d/apply"},{"additionalPlain":"About The Team\n\nThe Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful experience.The Trust & Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and stakeholders.If you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust & Safety team.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful </span><a href=\"http://experience.The\" style=\"font-size: 10pt\" class=\"postings-link\">experience.The</a><span style=\"font-size: 10pt\"> Trust &amp; Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and </span><a href=\"http://stakeholders.If\" style=\"font-size: 10pt\" class=\"postings-link\">stakeholders.If</a><span style=\"font-size: 10pt\"> you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust &amp; Safety team.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1708072107075,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","description":"<div><span style=\"font-size: 16px\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","id":"6f3368c9-6e84-489c-add3-4ad1fd4b9519","lists":[{"text":"What You Will Do","content":"<li>Provide regular analysis and reports on operational performance including compliance, escalations, quality, risk, and KPI tracking to guide decision-making and devise proactive solutions</li><li>Collaborate with cross-functional teams to build, automate, and improve on the availability, integrity, accuracy, and reliability of reporting, data logging, and data pipelines to be secure and compliant</li><li>Liaise with internal and external stakeholders for regulatory and compliance reports whenever needed, including issue investigation and report verification</li><li>Create and maintain performance management dashboards, visualizations, and trackers for Operations</li><li>Develop data-driven business insights and work with cross-functional teams to identify opportunities and implement new product features or system enhancements related to Trust &amp; Safety</li><li>Identify operational weaknesses and opportunities to help improve or innovate new processes and projects to drive user and vehicle quality, customer experience, and compliance to regulatory requirements</li><li>Prepare regulatory compliance reports to ensure adherence to relevant data protection, Insurance, earnings and safety regulations</li><li>Implement and maintain a good data management system to ensure the integrity, confidentiality, and availability of trust and safety-related data.</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in analytics and operations/compliance-related role</li><li>A wizard at working on and analyzing large datasets, with the ability to translate quantitative findings into action plan, demonstrated through understanding of&nbsp; statistical methods and modeling techniques.</li><li>Strong stakeholder and project management capabilities, with great attention to detail</li><li>Resilience and ability to take initiative in our constantly-changing fast-paced environment</li><li>Strong knowledge of SQL, Python, Google Suite, and MS Excel (advanced) is required</li><li>Experience in BI tools such as Tableau, Metabase, or Data Studio is a plus</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Operations Analyst, Data Operations (Trust & Safety)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519","applyUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719211012411,"description":"","descriptionPlain":"","id":"fc7c3413-6c4f-42bd-a048-70387bd490a4","lists":[{"text":"What you will do:","content":"<li>Process Analysis and Assessment: 1. Conduct comprehensive assessments of existing business processes to identify inefficiencies, bottlenecks, and areas for improvement. 2. Gather and analyze data to understand process performance and identify root causes of issues. 3. Develop process maps, flowcharts, and other documentation to visualize current state processes.</li><li>Improvement Strategy Development: Collaborate with stakeholders to design and develop strategies for process improvement, focusing on enhancing efficiency, quality, and customer satisfaction.</li><li>Implementation of Improvements: 1. Lead cross-functional teams in the implementation of process improvements, ensuring alignment with business goals and objectives. 2. Develop &amp; monitor detailed project plans, timelines, and milestones to guide improvement initiatives.</li><li>Change Management and Communication: Drive change management efforts &amp; communicate effectively to ensure smooth adoption of new processes and practices.</li><li>Performance Monitoring and Reporting: 1. Establish key performance indicators (KPIs) to measure the effectiveness of process improvements. 2. Conduct post-implementation reviews to assess the impact of changes and identify further improvement opportunities.</li><li>Continuous Improvement Culture: Provide mentorship and guidance to stakeholders on process improvement methodologies and tools.</li>"},{"text":"What you will need:","content":"<li>Bachelor's degree in Business Administration, Industrial Engineering, Operations Management, or a related field. A Master's degree is preferred.</li><li>Proven experience in business process improvement, process engineering, or related <a href=\"http://roles.Strong\">roles.</a></li><li>Strong knowledge of process improvement methodologies (e.g., Lean, Six Sigma, Kaizen).</li><li>Excellent analytical and problem-solving skills.</li><li>Exceptional project management skills, with experience leading cross-functional teams.</li><li>Strong communication and interpersonal skills, with the ability to influence and drive change.</li><li>Proficiency in process mapping and analysis tools (e.g., Visio, Lucidchart).</li><li>Ability to manage multiple projects and priorities in a fast-paced environment.</li>"},{"text":"Preferred Skills:","content":"<li>Fluent in English&nbsp;</li><li>Experience with data analysis tools (e.g., Excel, Tableau, Power BI).</li><li>Knowledge of change management principles and practices.</li><li>Familiarity with ERP and CRM systems, especially Salesforce</li><li>Experience in training and development related to process improvement.</li>"}],"text":"Operations Support Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4","applyUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4/apply"},{"additionalPlain":"Partnership team covers domestic institutions partners. We are the single point of contact to partners, where we are also responsible to orchestrate various divisions including product, legal, compliance, finance, commercial and other specific roles related internally to handle projects with partners. In the long run, we are mandated to connect with new partners across sectors, including transportations; retail, commerce and lifestyle; food and groceries; telco; payment gateways and others.\n","additional":"<div><span style=\"font-size: 9pt\">Partnership team covers domestic institutions partners. We are the single point of contact to partners, where we are also responsible to orchestrate various divisions including product, legal, compliance, finance, commercial and other specific roles related internally to handle projects with partners. In the long run, we are mandated to connect with new partners across sectors, including transportations; retail, commerce and lifestyle; food and groceries; telco; payment gateways and others.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1718252396509,"descriptionPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our Business Development and Sales team in Gojek Vietnam! The Business Development team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term growth strategy across all sectors and all Gojek products (GoFood, GoRide, GoCar, GoSend) to drive our business metrics! Its main objective is to identify, engage, and develop new business opportunities while maintaining relationships with existing clients, and continuously seek optimization to achieve mutual goals and improve business outcomes. This team will be the spearhead of the company, acting as the driving force behind revenue generation and market expansion.\n\nBusiness Development team is suitable for talents who have an interest in improving their ability to strategize business growth, sharpening their business acumen, and honing their negotiating skills.\nMost importantly, we are looking for proactive and self-starting individuals to join our team! No task is too small or big, regardless of whether it is within or outside the job scope; we take each assignment with pride and joy, all for creating value for Gojek! In return, we ensure that you are at the forefront of driving the most exciting business development initiatives in Gojek, some of which we have never done before!\n\nThis is a people management role with a commercial focus. \n","description":"<div><span style=\"font-size: 9pt\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our Business Development and Sales team in Gojek Vietnam! The Business Development team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term growth strategy across all sectors and all Gojek products (GoFood, GoRide, GoCar, GoSend) to drive our business metrics! Its main objective is to identify, engage, and develop new business opportunities while maintaining relationships with existing clients, and continuously seek optimization to achieve mutual goals and improve business outcomes. This team will be the spearhead of the company, acting as the driving force behind revenue generation and market expansion.</span></div><div><br></div><div><span style=\"font-size: 9pt\">Business Development team is suitable for talents who have an interest in improving their ability to strategize business growth, sharpening their business acumen, and honing their negotiating skills.</span></div><div><span style=\"font-size: 9pt\">Most importantly, we are looking for proactive and self-starting individuals to join our team! No task is too small or big, regardless of whether it is within or outside the job scope; we take each assignment with pride and joy, all for creating value for Gojek! In return, we ensure that you are at the forefront of driving the most exciting business development initiatives in Gojek, some of which we have never done before!</span></div><div><br></div><div><b style=\"font-size: 9pt\">This is a people management role with a commercial focus.&nbsp;</b></div>","id":"22056898-0433-418d-9e7f-b691455edd67","lists":[{"text":"What You Will Do ","content":"<li><b>Leadership and Strategy:</b></li><li>People manager of over 30+ across various sectors, division and categories&nbsp;</li><li>Develop and implement sales strategies to drive revenue growth and market shareLead, mentor, and manage a high-performing sales team to meet and exceed sales targets</li><li>Collaborate with executive leadership to align sales strategies and sales incentives with company goals and objectives</li><div><br></div><li><b>Sales Management:</b></li><li>Oversee the daily operations of the sales, business development and partnership department, ensuring  efficient processes and best practices</li><li>Mentor and provide guidance and motivation to the team</li><li>Monitor and analyze sales metrics to measure performance and identify areas for improvement</li><li>Manage sales incentives, OKRs, KPIs, budgets, forecasts, and financial objectives</li><li>Collaborate with clients/partners to create joint business plans aimed at achieving quarterly (QoQ) and yearly (YoY) growth targets</li><li>Business Development:Identify and pursue new business opportunities, including emerging markets and potential client with key partners</li><li>Develop and maintain strong relationships with key customers, partners, and stakeholdersNegotiate and close high-value deals, ensuring mutually beneficial terms</li><div><br></div><li><b>Market Analysis:</b></li><li>Conduct market research to stay informed about industry trends, competitive landscape, and customer needs</li><li>Utilize insights to refine sales strategies and adapt to changing market <a href=\"http://conditions.Product\" class=\"postings-link\">conditions.</a></li><div><br></div><li><a href=\"http://conditions.Product\" class=\"postings-link\"><b>Product</b></a><b> and Solution Knowledge:</b></li><li>Maintain a deep understanding of our products and solutions</li><li>Work closely with product development teams to ensure alignment between sales strategies and product offerings</li><li>Provide feedback on market demands and customer preferences to inform product development</li><div><br></div><li><b>Work closely with internal teams, including sales, marketing, product, and finance obtain their successful buy in to projects and programs</b></li><div><br></div>"},{"text":"What You Will Need  ","content":"<li>Minimum Bachelor’s degree</li><li>Minimum 15 years of professional experience in sales, partnership development or business development in companies such as start-ups, technology companies, management consulting, banking, or Fortune 500 companies</li><li>Data Analysis: Strong ability to crunch data and perform detailed data analysis. This includes interpreting complex datasets to derive actionable insights and support decision-making.</li><li>P&amp;L Understanding: Good understanding of Profit and Loss statements, with the ability to analyze financial performance and identify <a href=\"http://trends.Business\" class=\"postings-link\">trends.</a></li><li><a href=\"http://trends.Business\" class=\"postings-link\">Business</a> Acumen: Solid business acumen, enabling the development, management, and execution of business agreements and contracts. This involves a deep comprehension of business operations and strategic <a href=\"http://planning.Critical\" class=\"postings-link\">planning.</a></li><li><a href=\"http://planning.Critical\" class=\"postings-link\">Critical</a> Thinking and Problem Solving: Draws sound conclusions based upon a mixture of analysis and experience. Able to identify breakthrough solutions during tough negotiations or large-scale implementations with strategic <a href=\"http://partners.Communications\" class=\"postings-link\">partners.</a></li><li><a href=\"http://partners.Communications\" class=\"postings-link\">Communications</a> Skills: Promotes an environment of open communication. Convinces and engages others by using compelling arguments. Able to rigorously manage a portfolio of projects with strategic partners, unblock issues &amp; risks and manage expectations to ensure they are completed within target timelines and stakeholder <a href=\"http://expectations.B2B\" class=\"postings-link\">expectations.</a></li><li><a href=\"http://expectations.B2B\" class=\"postings-link\">B2B</a> Negotiation Skills: A fair, unbiased mediator and uses diplomacy and tact to diffuse tense situations comfortably</li><li>Resiliency : Demonstrates resilience &amp; composure, even in difficult or adverse circumstances. Makes and carries through unpopular or difficult decisions that are in the best interest of the team. Is able to resist the pressure to make quick decisions where due consideration is <a href=\"http://required.Stakeholder\" class=\"postings-link\">required.</a></li><li><a href=\"http://required.Stakeholder\" class=\"postings-link\">Stakeholder</a> Management: Ability to develop strong, long lasting relationships with both internal and external stakeholders at all levels. Persuades and influences effectively by building support for ideas and initiatives through the effective presentation of facts and evidence. Identifies and anticipates that the partner and stakeholder needs to gain their commitment. Owns the end-to-end relationship with equivalent team and functional leads both internally and <a href=\"http://externally.Abilities\" class=\"postings-link\">externally.</a></li><li><a href=\"http://externally.Abilities\" class=\"postings-link\">Abilities</a> to navigate and execute in a highly ambiguous environment</li><li>Local candidates is a must</li><div><br></div>"}],"text":"Partnership Senior Manager","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our Business Development and Sales team in Gojek Vietnam! The Business Development team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term growth strategy across all sectors and all Gojek products (GoFood, GoRide, GoCar, GoSend) to drive our business metrics! Its main objective is to identify, engage, and develop new business opportunities while maintaining relationships with existing clients, and continuously seek optimization to achieve mutual goals and improve business outcomes. This team will be the spearhead of the company, acting as the driving force behind revenue generation and market expansion.</span></div><div><br></div><div><span style=\"font-size: 9pt;\">Business Development team is suitable for talents who have an interest in improving their ability to strategize business growth, sharpening their business acumen, and honing their negotiating skills.</span></div><div><span style=\"font-size: 9pt;\">Most importantly, we are looking for proactive and self-starting individuals to join our team! No task is too small or big, regardless of whether it is within or outside the job scope; we take each assignment with pride and joy, all for creating value for Gojek! In return, we ensure that you are at the forefront of driving the most exciting business development initiatives in Gojek, some of which we have never done before!</span></div><div><br></div><div><b style=\"font-size: 9pt;\">This is a people management role with a commercial focus.&nbsp;</b></div>","descriptionBodyPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our Business Development and Sales team in Gojek Vietnam! The Business Development team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term growth strategy across all sectors and all Gojek products (GoFood, GoRide, GoCar, GoSend) to drive our business metrics! Its main objective is to identify, engage, and develop new business opportunities while maintaining relationships with existing clients, and continuously seek optimization to achieve mutual goals and improve business outcomes. This team will be the spearhead of the company, acting as the driving force behind revenue generation and market expansion.\n\nBusiness Development team is suitable for talents who have an interest in improving their ability to strategize business growth, sharpening their business acumen, and honing their negotiating skills.\nMost importantly, we are looking for proactive and self-starting individuals to join our team! No task is too small or big, regardless of whether it is within or outside the job scope; we take each assignment with pride and joy, all for creating value for Gojek! In return, we ensure that you are at the forefront of driving the most exciting business development initiatives in Gojek, some of which we have never done before!\n\nThis is a people management role with a commercial focus. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/22056898-0433-418d-9e7f-b691455edd67","applyUrl":"https://jobs.lever.co/GoToGroup/22056898-0433-418d-9e7f-b691455edd67/apply"},{"additionalPlain":"About The Team\n\nThe Payment Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF regulated entities with Bank Indonesia as the regulator. As a Payment Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \n\nThe Payment Compliance team itself combines  youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment and give advice to many other functions within the GoTo ecosystem. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The Payment Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF regulated entities with Bank Indonesia as the regulator. As a Payment Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div><br></div><div>The Payment Compliance team itself combines&nbsp; youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment and give advice to many other functions within the GoTo ecosystem.&nbsp;</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Legal","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713511717571,"descriptionPlain":"About The Role\n\nThe Compliance Manager is a strategic role within GoTo Financial payments division. As a junior member of the team, she/he will be expected to be the support GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial payments business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting and submissions to the regulators with primary objective of  ensuring the implementation of payments regulations, industry standards and good corporate governance principles in the operations of the Company/Group. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The Compliance Manager is a strategic role within GoTo Financial payments division. As a junior member of the team, she/he will be expected to be the support GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial payments business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting and submissions to the regulators with primary objective of&nbsp; ensuring the implementation of payments regulations, industry standards and good corporate governance principles in the operations of the Company/Group. </div>","id":"19489ced-76de-411a-8205-8aebdef22d4c","lists":[{"text":"What You Will Do","content":"<li>Support Compliance and Regulatory Affairs matter in GoTo Financial&nbsp; Payments operations, which includes but not limited to business/product reporting and approval process with the regulators, compliance advisory assistance to business unit, as well as technical regulatory assessment</li><li>Provide Compliance advisory assistance for offline and online payments operations, in both consumer and merchant-facing operation</li><li>Create and maintain the latest update of payments regulations databases and&nbsp; provide/disseminate assessment on such regulations to the internal&nbsp; units in GoTo Financial</li><li>Provide assistance and support to the Head of Compliance and Senior Manager of Payments Compliance in any external engagements with Bank Indonesia, other regulators, industry associations and other external stakeholders</li><li>Give continuous support on the creation, standardization and implementation of Payments Compliance, policies, terms &amp; conditions, internal working procedures and standard operational guidelines;</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What You Will Need","content":"<li>Bachelor Degree in Law and Accounting. Having a master’s degree would be an advantage.</li><li>Possess certifications in Risk Management/ IT Audit will be an advantage.</li><li>At least 4 years of mixed experience in the area of payments policy/ regulatory compliance and past working experience in Bank Indonesia/ Otoritas Jasa Keuangan will be an advantage.&nbsp;</li><li>Intermediate level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to details with the capacity of identifying risks and proactively choosing the best solutions, and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, include builds credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"Payments Compliance Manager - #9917","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The Compliance Manager is a strategic role within GoTo Financial payments division. As a junior member of the team, she/he will be expected to be the support GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial payments business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting and submissions to the regulators with primary objective of&nbsp; ensuring the implementation of payments regulations, industry standards and good corporate governance principles in the operations of the Company/Group. </div>","descriptionBodyPlain":"About The Role\n\nThe Compliance Manager is a strategic role within GoTo Financial payments division. As a junior member of the team, she/he will be expected to be the support GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial payments business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting and submissions to the regulators with primary objective of  ensuring the implementation of payments regulations, industry standards and good corporate governance principles in the operations of the Company/Group. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/19489ced-76de-411a-8205-8aebdef22d4c","applyUrl":"https://jobs.lever.co/GoToGroup/19489ced-76de-411a-8205-8aebdef22d4c/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - People & Culture","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719221486584,"description":"","descriptionPlain":"","id":"188afe61-267f-4de2-914d-af8177627902","lists":[{"text":"What you will do - maximum 8 bullet points","content":"<li>Perform business partner role by understanding the business needs in the short, medium and long term and proactively suggesting and leading initiatives and projects to solve strategic people and organizational challenges for his/her respective business.</li><li>Ensures that PAC and business solutions are on-time, on-budget, and to a high standard of quality.</li><li>Implements and advocates for programs, policies, and procedures to support the organizational culture.</li><li>Coaches, mentors, conducts career conversations, and able to provide objective and actionable feedback to team members, peers, and other stakeholders.</li><li>Navigates stakeholder relationship challenges well (e.g. reconciles, anticipates needs and wants, balances long and short term relationship trade-offs), and comes up with solutions as appropriate.</li><li>Recognizes and takes appropriate action to mitigate risk (organizational, legal, employee relations, etc) and develops options to mitigate them.</li><li><b>Workplace Issues &amp; Grievances:</b> Confidentially carry-out high end &amp; high-risk investigations/enquiries; Administer grievance procedures, employee issues, complaints and misconduct.</li><li>Managing Labor authority inspections under PF, ESI, PT &amp; other applicable statutory &amp; Labor laws, PF withdrawals and transfers.</li><li><b>Employment Laws:</b> Provide advice and guidance to leadership regarding any changes to ER / Labor Laws / Rules / Regulations, Notifications, Statutory Registrations/Renewals, Filing of Compliance returns to Government Authorities, <a href=\"http://etc.Policy\">etc.</a></li><li><b>Policy Review &amp; Development: </b>Manage all dealings with central and state government authorities for labor law reforms &amp; monitor amendments / developments from time to time in relationships with clients.</li><li><b>Employee Litigations:</b> handling all matters related to litigation, representing the organization in Labor courts and tribunals.</li><li>Labor Compliance: Ensuring complete adherence of the organization to statutory dealings with the government authorities including, PF Commissioner, DLC, ALC &amp; Police, <a href=\"http://etc.Obligations\">etc.</a></li><li>Obligations for ER/Labor compliance, including / Statutory Registrations/Renewals, Filing of Compliance returns to Government Authorities.</li><li>Manage employee escalations pertaining to PF, ESI &amp; Retirals etc.</li>"},{"text":"What you will need - maximum 8 bullet points","content":"<li>10+ years of total experience in ER/LER or related fields, with 3-5 years managing end-to end HR/Statutory compliance.</li><li>Willingness to work in a complex environment.</li><li>Well versed and updated on Labor law changes and their interpretations and impacts.</li><li>Experience dealing with labor courts, central &amp; state authorities, PF authorities, and representing organizations on matters related to labor and litigation.</li><li>Experience with a matrix driven global organization</li><li>proven track record of building strong relationships with stakeholders</li><li>Excellent written and verbal communication – English.</li>"}],"text":"People Business Partner & Employee Relations Lead","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/188afe61-267f-4de2-914d-af8177627902","applyUrl":"https://jobs.lever.co/GoToGroup/188afe61-267f-4de2-914d-af8177627902/apply"},{"additionalPlain":"\n","additional":"<div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - People & Culture","location":"Jakarta","team":"HR Information Systems","allLocations":["Jakarta","Singapore"]},"createdAt":1718958420176,"descriptionPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","description":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","id":"8fe35112-8410-4cf3-9a50-4c7287e95b57","lists":[{"text":"What You Will Do","content":"<li><b>HRIS Management &amp; Operations: </b>Operate and administer end-to-end Workday as our HRIS platform, serve as technical lead for Workday Core HCM, Talent Management, Absence, and Compensation. Provide technical support on day-to-day HR processes such as operations, payroll, performance management, and merit cycle. Act as a subject matter expert on HRIS-related inquiries and troubleshoot any technical issues that arise.</li><li><b>Process Improvement: </b>Identify opportunities to streamline HR processes using HRIS, automate manual efforts, and increase overall efficiency. Partner with cross-functional teams to identify opportunities for improvement, gather requirements, design, recommend, and implement system-driven solutions.</li><li><b>System Implementation &amp; Integration: </b>Collaborate with partners (HR and IT team) to configure and optimize HRIS modules, workflows, and integrate with other systems such as Payroll, ATS, and Finance to create seamless data flows. Lead HRIS system update and implementation of new HRIS modules, working with vendors and internal teams to plan and execute the process smoothly and successful adoption by stakeholders.</li><li><b>Report Development: </b>Develop and maintain custom reports, dashboards, and visualizations within HRIS to provide insightful HR metrics and analytics to stakeholders.</li><li><b>User Access Management and Compliance: </b>Manage user access and permissions to ensure data security and privacy compliance. Ensure HRIS compliance with relevant data protection and privacy regulations. Monitor and audit HR data to maintain accuracy, quality, and integrity, implementing necessary corrections and preventive solutions.</li><li><b>Training: </b>Provide training to HR staff and end-users on using and familiarities with the HRIS in respective to their roles.</li>"},{"text":"What You Will Need","content":"<li>Proven experience (typically 5+ years) in HRIS management and optimization.</li><li>Strong proficiency with Workday and related HR systems (Lever, Degreed, Larona, etc).Strong understanding of HR processes and workflows, with the ability to translate business requirements into HRIS solutions.</li><li>Excellent project management and problem solving skills, capable of handling multiple initiatives in a fast-paced environment.</li><li>Strong influencing skills with the ability to communicate clearly and confidently with stakeholders.</li><li>Strong managerial and leadership skills with the ability to guide, develop, and mentor team members to make things happen.</li><li>Experience communicating effectively across teams in markets across the region.</li><li><b>Preferred Qualifications: </b>Certification in Workday in one of the following modules: Core HCM, Advanced Compensation, Reporting, Talent, Performance, or Absence Management. Experience in SaaS HR system configuration. Experience with downstream system integrations such as Google Workspace, Google Cloud Platform, Workato, and JIRA/Asana.</li>"}],"text":"People Systems Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","descriptionBodyPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57","applyUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57/apply"},{"additionalPlain":"Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714372709159,"descriptionPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","description":"<div><span style=\"font-size: 10pt\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","id":"44117b68-3ece-40ac-91c1-920caadfe5dd","lists":[{"text":"What You Will Do","content":"<li>Design and construct scalable streaming or batch data pipelines to meet various business requirements.</li><li>Establish reliable monitoring and alerting systems to assess data pipeline performance.</li><li>Identify potential bottlenecks in the system and optimize as needed.</li><li>Manage the data science infrastructure to streamline model development and deployment.</li><li>Mentor team members by conducting code reviews and sharing knowledge.</li>"},{"text":"What You Will Need","content":"<li>Experience with streaming processing and Change Data Capture (CDC) tools such as Debezium, Flink, Kafka, etc. is necessary.</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Docker, RDBMS, and NoSQL Databases is desirable.</li><li>Proficiency in Python and SQL is expected.</li><li>Must be self-driven, with a strong sense of ownership, and capable of working independently to solve problems and develop solutions.</li><li>Project management skills to successfully drive large-scale projects from initiation to completion are needed.</li><li>Excellent communication skills, including proficiency in English, are required.</li><li>Understanding of machine learning techniques and algorithms is advantageous.</li>"}],"text":"Principal Data Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","descriptionBodyPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","hostedUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd","applyUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd/apply"},{"additionalPlain":"About the Team\n\nThe Marketplace Supply Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace, which deeply impacts the everyday experiences of our customers (riders) and drivers. We are responsible for the pillars of technology, science, and strategy across the supply-and-demand, matching of over two billion global orders in 2019. The gist of our role is to oversee that Gojek's millions of customers are paired with the right drivers at the optimum price at the right time. This supply and demand matching is the core problem that our Product Team tackles every day. \n\nWe are a tight-knit group made up of avid readers, amateur gamers, coffee connoisseurs and (guilty) reality show watchers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company! \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Marketplace Supply Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace, which deeply impacts the everyday experiences of our customers (riders) and drivers.&nbsp;We are responsible for the pillars of technology, science, and strategy across the supply-and-demand, matching of over two billion global orders in 2019. The gist of our role is to oversee that Gojek's millions of customers are paired with the right drivers at the optimum price at the right time. This supply and demand matching is the core problem that our Product Team tackles every day.&nbsp;</div><div><br></div><div>We are a tight-knit group made up of avid readers, amateur gamers, coffee connoisseurs and (guilty) reality show watchers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!&nbsp;</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1698659054507,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Principal Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you will get to design, manage, and improve various applications. You will also get to enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part is your ability to own the future of these products, ensuring its quality and longevity, and seeing the results of your efforts in people's everyday lives.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our next Principal Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you will get to design, manage, and improve various applications. You will also get to enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity.&nbsp;In our humble opinion, the coolest part is your ability to own the future of these products, ensuring its quality and longevity, and seeing the results of your efforts in people's everyday lives.</div><div><br></div><div><br></div>","id":"a54f9d2d-4b2d-43c3-bb82-c6705beefbcf","lists":[{"text":"What You Will Do ","content":"<li>Be solely responsible for the entire life-cycle of high complexity projects or features including engineering design, development, and deployment within their stream</li><li>Ensure the planning &amp; timely delivery of work within their stream, under the guidance from more experienced engineers</li><li>Improve code structure and architecture in service of test ability and maintainability, and; write, co-write, and review design documentation. Participate in the design review process, seeking and providing constructive criticism</li><li>Be accountable for the operationalization of the tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Split complex engineering task into smaller components which can be developed by other engineers on the team</li><li>Mentor other engineers on an individual basis and participate in the hiring process</li>"},{"text":"What You Will Need","content":"<li>At least 8 years of relevant, hands-on experience with Clojure, Golang, or Java</li><li>Able to go into depth across tech stack used in the product</li><li>Experience working on large-scale event-driven micro-services architecture with an active use of Kafka and can architect solutions based on this pattern</li><li>Familiarity with basic programming principles such as SOLID and TDD</li><li>Intermediate experience with Linux OS and is able to troubleshoot issues</li><li>Understands why we need to test code and has implemented tests</li><li>Able to understand/discuss design and performance trade offs in complex systems</li>"}],"text":"Principal Software Engineer - Marketplace","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our next Principal Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you will get to design, manage, and improve various applications. You will also get to enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity.&nbsp;In our humble opinion, the coolest part is your ability to own the future of these products, ensuring its quality and longevity, and seeing the results of your efforts in people's everyday lives.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Principal Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you will get to design, manage, and improve various applications. You will also get to enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part is your ability to own the future of these products, ensuring its quality and longevity, and seeing the results of your efforts in people's everyday lives.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a54f9d2d-4b2d-43c3-bb82-c6705beefbcf","applyUrl":"https://jobs.lever.co/GoToGroup/a54f9d2d-4b2d-43c3-bb82-c6705beefbcf/apply"},{"additionalPlain":"About the Team\n\nOur Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1715060912791,"descriptionPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"426f18b4-739e-4da0-a74b-446c349c0a31","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Collaborate with cross functional teams (Mobile, DevOps, UX, QA etc.) on execution and delivery</li><li>Partner with the team to define and execute the feature roadmap</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"What You Will Need","content":"<li>Should have at least 7 years of hands-on experience in designing, developing, testing and deploying applications at scale</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Principal Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31","applyUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31/apply"},{"additionalPlain":"About The Team\n\nThis vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.  \n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>This vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.&nbsp;&nbsp;</div><div><br></div>","categories":{"department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1718084687109,"descriptionPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","description":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","id":"a1ebb8d4-0af0-4707-9efb-8f52aa781c44","lists":[{"text":"What You Will Do","content":"<li>Help define the roadmap, goals, and vision for the product experience</li><li>Work with design leads, product heads, marketing and engineers to build/improve user experience and ways of working towards that vision</li><li>Manage projects, solve complex problems, and enable your team to deliver delightful solutions that drive impact</li><li>Build systems for design documentation &amp; help establish processes to ensure seamless collaboration</li><li>Mentor and coach a team of designers, improve stakeholders grasp and application of design thinking</li><li>And most importantly, make sure your team is engaged well and building things that make them successful</li>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in product design, but still willing to learn more about product research</li><li>Proficiency in all areas of digital product design; visual design, user experience design, user research prototyping, advocacy and building showcases. Additional exposure to motion, sound, video and other craft are welcome</li><li>Ability to draw insights from both qualitative &amp; quantitative data, and further identify problem areas to work on.</li><li>Ability to design, advocate and prioritize user research with our research team</li><li>Knowledge in design fundamentals, such as design thinking frameworks, HCI principles, and being able to take on a structured approach in solving problems</li><li>Excellent organizational, project management, and collaboration skills to manage a wide range of stakeholders</li>"},{"text":"","content":"<li><br></li>"}],"text":"Product Design Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44","applyUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44/apply"},{"additionalPlain":"About the Team\n\nThe Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. \n\nWe’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers. \n\nThe Loyalty, Incentives & Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more. \n\nWe are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .\n\n\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. </div><div><br></div><div>We’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers.&nbsp;</div><div><br></div><div>The Loyalty, Incentives &amp; Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more.&nbsp;</div><div><br></div><div>We are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .</div><div><br></div><div><br></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718798053606,"descriptionPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","id":"e407433b-435a-4607-89bd-5faf51cf622e","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of a senior product designer, and follow the predefined process set forth by the team</li><li>Able to comprehend the product briefs and be able to present the ideas/solutions to the team under the supervision of the product design lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Define end-to-end wireframe and wireflow for features using standard wireframing tools</li><li>Document the design process for each feature, such as research findings, ideations, usability tests, release, and monitor the impact after the product release</li><li>Contribute to the team cadence discussion and make occasional short presentations to the team, as well as present team’s updates if needed</li><li>Proactively seek/give feedback from other stakeholders to make sure concepts are meeting the intended project goal</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of relevant experience in the product design industry</li><li>Familiar with data and can identify problem areas, further map out the user journey, and break the problems into smaller chunks</li><li>Use basic analytics tools to gather customer data (funnel)&nbsp;</li><li>Possess a good knowledge of design fundamentals, such as design thinking framework and other frameworks to develop products</li><li>Able to sketch the ideas into wireframes, learn how to make wireflow, and do wireframing for well-defined features</li><li>Good knowledge of the tools, such as Overflow, Miro, Sketch, Figma, or similar ones that are widely used by Product Designers</li><li>Knowledge of design validation, either through quantitative or qualitative research</li><li>Preferably some knowledge of service design and experience with working on mobile app design</li>"}],"text":"Product Designer - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e","applyUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e/apply"},{"additionalPlain":"About The Team\n\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718166115141,"descriptionPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","description":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","id":"b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirements and the impact of each feature, as well as the go-to-market strategy to ensure adoption of the features</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in product management experience</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Growth","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","applyUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba/apply"},{"additionalPlain":"About The Team\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. \n\nThe Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.\n","additional":"<div><b>About The Team</b></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology.&nbsp;</div><div><br></div><div>The Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.</div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719305116114,"descriptionPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","id":"6f05ee4a-fa49-4aca-8990-c6607cd7cf09","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched&nbsp;</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirement and the impact of each feature as well as the go to market strategy to ensure adoption of the features.&nbsp;</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of total experience, with 2-3 years experience specifically in product management</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09","applyUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09/apply"},{"additionalPlain":"About the Team\n\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit work with us and let's solve the problems with technology. The Merchant Platform team focuses on building a platform ecosystem for merchants in GoTo. We are building the infrastructure to help our merchants manage their business with GoTo including but not limited to onboarding, reporting, and user management.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit work with us and let's solve the problems with technology. The Merchant Platform team focuses on building a platform ecosystem for merchants in GoTo. We are building the infrastructure to help our merchants manage their business with GoTo including but not limited to onboarding, reporting, and user management.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713756621536,"descriptionPlain":"About the Role\n\nAs a Product Manager for Merchant Platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing the merchant experience, in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the merchant platform.\n","description":"<div>About the Role</div><div><br></div><div>As a Product Manager for Merchant Platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing the merchant experience, in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the merchant platform.</div>","id":"4174ba7b-c2d9-4cba-a725-da3b0a4265ee","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched&nbsp;</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirement and the impact of each feature as well as the go to market strategy to ensure adoption of the features.&nbsp;</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points.</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality.</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders.</li>"},{"text":"What You Will Need","content":"<li>Min of 5-6 years of experience in product management experience</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Able to work with agile product development teams and identify new ways to help your team be effective. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Merchant Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role</div><div><br></div><div>As a Product Manager for Merchant Platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing the merchant experience, in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the merchant platform.</div>","descriptionBodyPlain":"About the Role\n\nAs a Product Manager for Merchant Platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing the merchant experience, in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the merchant platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4174ba7b-c2d9-4cba-a725-da3b0a4265ee","applyUrl":"https://jobs.lever.co/GoToGroup/4174ba7b-c2d9-4cba-a725-da3b0a4265ee/apply"},{"additionalPlain":"About the team\n\nOur Product Marketing team is a part of the GoFood Business team based in Jakarta. The team consists of growth marketing, brand managers, brand executives, marketing analytics, and more. They are the magicians who combine logic and magic to create a brand that people love. Our main responsibility is to develop GoFood’s marketing campaign that ensures GoFood's continuous growth. Making sure everyone knows, always thinks about GoFood and we also want everyone to stick with GoFood. More importantly, we want to deliver joy in the lives of our consumers through the assortment, recommendations & rewards in our platform. We are also a data-driven team that strives to continuously improve our efficiency. Currently, our team has been working on a lot of product innovation, branding, and promotional campaigns, which will help GoFood maintain our leadership in the market.\n\nGoFood Marketing team believes the growth of the business is driven by the growth of the talents. Of course, we care about the business number, yet we also care about each other’s well-being and growth journey. Other than enjoying finding that “a-ha!” moments when swimming through the sea of data, our family also enjoys bonding over food and sharing our hobbies.\n\n","additional":"<div><b>About the team</b></div><div><br></div><div>Our Product Marketing team is a part of the GoFood Business team based in Jakarta. The team consists of growth marketing, brand managers, brand executives, marketing analytics, and more. They are the magicians who combine logic and magic to create a brand that people love. Our main responsibility is to develop GoFood’s marketing campaign that ensures GoFood's continuous growth. Making sure everyone knows, always thinks about GoFood and we also want everyone to stick with GoFood. More importantly, we want to deliver joy in the lives of our consumers through the assortment, recommendations &amp; rewards in our platform. We are also a data-driven team that strives to continuously improve our efficiency. Currently, our team has been working on a lot of product innovation, branding, and promotional campaigns, which will help GoFood maintain our leadership in the market.</div><div><br></div><div>GoFood Marketing team believes the growth of the business is driven by the growth of the talents. Of course, we care about the business number, yet we also care about each other’s well-being and growth journey. Other than enjoying finding that “a-ha!” moments when swimming through the sea of data, our family also enjoys bonding over food and sharing our hobbies.</div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718798386315,"descriptionPlain":"About the Role\n\nFasten your helmet and climb aboard, if you’re ready to be our Marketing Executive for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Preparing and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in implementing campaign plans such as communication strategy, channels, and promo based on the given budget.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Fasten your helmet and climb aboard, if you’re ready to be our Marketing Executive for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Preparing and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in implementing campaign plans such as communication strategy, channels, and promo based on the given budget.</div><div><br></div><div><br></div>","id":"9f1897da-a914-439d-9454-e40d10735858","lists":[{"text":"What you will do","content":"<li>Ensure execution of integrated campaign plans that include activations across many formats and channels (e.g. video, interactive, social) to be done well.&nbsp;</li><li>Partner with the creative and media team to develop robust and relevant communication for our different segments, using various drivers to impact growth according to the different personas.</li><li>Collaborate with the Product team to not only develop and execute strong GTMs for new product launches but also become an integral partner in sharing input and consumer insights for product development.</li><li>Creating engaging and informative content for digital marketing, website, blog, social media, and any other content marketing channels that the business might leverage to improve the conversion funnel, particularly for the nonactive or dormant users, supported by branding, copywriting, and creative teams.&nbsp;</li><li>Identifying improvement areas for the incumbent marketing process or user journey and implementing the changes required for it. Including but not limited to CRM user journey, performance marketing, and social media engagement.</li><li>Collaborate with other cross-functional teams in making sure campaigns are executed well</li><li>Manage the timeline for content creation and communication schedule.</li>"},{"text":"What you will need","content":"<li>Bachelor's degree from a reputable university or equivalent practical experience.</li><li>At least 1 year experience in Product Marketing/Growth Marketing/Marketing Analyst</li><li>Excellent Project Management skills - including execution, reviewing, and reporting.</li><li>Proficient with spreadsheets (Excel, Google Sheets) and presentation tools (PowerPoint, Google Slides)</li><li>Had prior experience in planning and using in-app and external communication channels (PN, Email, WhatsApp, etc.)</li><li>Excellent verbal and written communication skills in English and Indonesian</li><li>Are have marketing / creative knowledge and experience (on creatives, communications, copy, and content)</li><li>Experience working with cross-functional/cross-discipline stakeholders, and drafting and leading communication plans for internal stakeholders.</li>"}],"text":"Product Marketing Executive","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Fasten your helmet and climb aboard, if you’re ready to be our Marketing Executive for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Preparing and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in implementing campaign plans such as communication strategy, channels, and promo based on the given budget.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nFasten your helmet and climb aboard, if you’re ready to be our Marketing Executive for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Preparing and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in implementing campaign plans such as communication strategy, channels, and promo based on the given budget.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9f1897da-a914-439d-9454-e40d10735858","applyUrl":"https://jobs.lever.co/GoToGroup/9f1897da-a914-439d-9454-e40d10735858/apply"},{"additionalPlain":"About The Team\n\nOur Product Marketing team is a part of the GoFood Business team based in Jakarta. The team consists of growth marketing, brand managers, brand executives, marketing analytics, and more. They are the magicians who combine logic and magic to create a brand that people love. Our main responsibility is to develop GoFood’s marketing campaign that ensures GoFood continuous growth. Making sure everyone knows, always thinks about GoFood and we also want everyone to stick with GoFood. More importantly, we want to deliver joy in the life of our consumer through the assortment, recommendation & rewards in our platform. We are also a data-driven team who strive to continuously improve our efficiency.\nCurrently, our team has been working on a lot of product innovation, branding and promotional campaigns, which will help GoFood maintain our leadership in the market.\n\nGoFood Marketing team believes the growth of the business is driven by the growth of the talents. Of course we care about the business number, yet we also care about each other’s well-being and growth journey. Other than enjoying finding that “a-ha!” moments when swimming through the sea of data, our family also enjoys bonding over food and sharing our hobbies.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Product Marketing team is a part of the GoFood Business team based in Jakarta. The team consists of growth marketing, brand managers, brand executives, marketing analytics, and more. They are the magicians who combine logic and magic to create a brand that people love. Our main responsibility is to develop GoFood’s marketing campaign that ensures GoFood continuous growth. Making sure everyone knows, always thinks about GoFood and we also want everyone to stick with GoFood. More importantly, we want to deliver joy in the life of our consumer through the assortment, recommendation &amp; rewards in our platform. We are also a data-driven team who strive to continuously improve our efficiency.</div><div>Currently, our team has been working on a lot of product innovation, branding and promotional campaigns, which will help GoFood maintain our leadership in the market.</div><div><br></div><div>GoFood Marketing team believes the growth of the business is driven by the growth of the talents. Of course we care about the business number, yet we also care about each other’s well-being and growth journey. Other than enjoying finding that “a-ha!” moments when swimming through the sea of data, our family also enjoys bonding over food and sharing our hobbies.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707306211878,"descriptionPlain":"About The Role\n\nFasten your helmet and climb aboard, if you’re ready to be our Marketing Manager for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Managing marketing strategy and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in planning, implementing campaign plan such as communication strategy, channels, and promo based on the given budget.\n","description":"<div><b>About The Role</b></div><div><br></div><div>Fasten your helmet and climb aboard, if you’re ready to be our Marketing Manager for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Managing marketing strategy and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in planning, implementing campaign plan such as communication strategy, channels, and promo based on the given budget.</div>","id":"68d7d220-1f05-49ea-9f34-fffe0ef75aea","lists":[{"text":"What You Will Do","content":"<li>Develop and execute integrated campaign plans that include activations across many formats and channels (e.g. video, interactive, social).&nbsp;</li><li>Collaborate with the GoFood business team in conceptualizing, designing and building strategies and campaigns to reach GoFood business goals and visions.</li><li>Partner with the creative and media team to develop robust and relevant communication for our different segments, using various drivers to impact growth according to the different personas.</li><li>Collaborate with the Product team to not only develop and execute strong GTMs for new product launches, but also become an integral partner in sharing input and consumer insights for product development.</li><li>Creating engaging and informative contents for digital marketing, website, blog, social media, and any other content marketing channels that the business might leverage to improve the conversion funnel particularly for the non active or dormant users, supported by branding, copywriter and creative teams.&nbsp;</li><li>Identifying improvement areas for the incumbent marketing process or user journey and implementing the changes required for it. Including but not limited to CRM user journey, performance marketing, and social media engagement.</li><li><br></li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree from reputable universities or equivalent practical experience.</li><li>5-6 years of experience working as a product marketing manager, analytics manager, or strategy &amp; planning manager in technology, start-up or FMCG.</li><li>Experience in crafting marketing, communication and business strategy.</li><li>Experience in end-to-end campaign development, from planning, executing and reporting.</li><li>Experience working with cross-functional/cross-discipline stakeholders, and drafting and leading communication plans for internal stakeholders.</li><li>Experience with solving problems and thinking strategically in order to translate user tension into business opportunities for company growth.</li><li>Experience in brand health tracking on the reporting, trend monitoring and developing an improvement plan.</li>"}],"text":"Product Marketing Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Fasten your helmet and climb aboard, if you’re ready to be our Marketing Manager for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Managing marketing strategy and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in planning, implementing campaign plan such as communication strategy, channels, and promo based on the given budget.</div>","descriptionBodyPlain":"About The Role\n\nFasten your helmet and climb aboard, if you’re ready to be our Marketing Manager for GoFood. In this role, you will be part of the GoFood Marketing team based in Jakarta, Indonesia. Managing marketing strategy and executing go-to-market strategy for GoFood products, delivering the joy of food and culinary to new and loyal customers alike. This role is crucial in planning, implementing campaign plan such as communication strategy, channels, and promo based on the given budget.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/68d7d220-1f05-49ea-9f34-fffe0ef75aea","applyUrl":"https://jobs.lever.co/GoToGroup/68d7d220-1f05-49ea-9f34-fffe0ef75aea/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717052781419,"descriptionPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","description":"<div><span style=\"font-size: 10.5pt\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","id":"4ba1eea8-feed-4843-be2e-93a21f0eadb1","lists":[{"text":"What Will You Do","content":"<li>Perform exploratory data analysis using SQL and present interesting findings to business stakeholders to drive business and strategic decisions</li><li>Design and analyze experiments to improve service quality and quantity</li><li>Build and maintain self-serve data products such as dashboards (Looker &amp; Tableau) and tables to reduce time to insights</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Should have at least 2-3 years of practical experience in <a href=\"http://SQL.Prior\" class=\"postings-link\">SQL.</a></li><li><a href=\"http://SQL.Prior\" class=\"postings-link\">Prior</a> experience with applied statistics, experimental design is a <a href=\"http://plus.Able\" class=\"postings-link\">plus.</a></li><li><a href=\"http://plus.Able\" class=\"postings-link\">Able</a> to tell a coherent data narrative using visualization tools and able to set best practices in data visualization to convey a product insight through impactful <a href=\"http://graphs.Proven\" class=\"postings-link\">graphs.</a></li><li><a href=\"http://graphs.Proven\" class=\"postings-link\">Proven</a> ability to recognize business needs and ability to communicate with multiple stakeholders including PMs, business and <a href=\"http://operations.Balance\" class=\"postings-link\">operations.</a></li><li><a href=\"http://operations.Balance\" class=\"postings-link\">Balance</a> attention to detail with swift execution.</li><div><br></div>"}],"text":"Region Analytics Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","descriptionBodyPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1","applyUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715919574159,"descriptionPlain":"About The Role\n\nRegional Merchant Engagement Manager has the responsibility to develop the assigned regional market by creating strategies to keep merchants within the region actively engaged and have their revenue grown. This role reports to Regional Sales Senior Manager.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">Regional Merchant Engagement Manager has the responsibility to develop the assigned regional market by creating strategies to keep merchants within the region actively engaged and have their revenue grown. This role reports to Regional Sales Senior Manager.</span></div>","id":"ea0f2d5a-c9d5-4202-ac91-a671b128bfb4","lists":[{"text":"What You Will Do:","content":"<li>Develop tailored-local plan to educate and engage merchants in his/her territory based on their lifecycle stages, i.e: create partnerships, weekly gatherings, collaborate with marketing team for local programs</li><li>Ensure the local plan to be executed by district, branch &amp; satellite teams for both managed &amp; unmanaged merchants</li><li>Liaise with HQ Merchant Engagement Team to develop and execute nationwide/main local key program and initiatives</li><li>Liaise with product team in HQ (GoFood, GoPay, etc.) for the execution of region-centric projects</li><li>Gather and develop key insights to continuously improve practices and standard of merchant engagement activities</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Bachelor's degree in any field (Top tier University is preferable) </li><li>5-7 years of experience within mid-to-senior management function (FMCG, and Telecommunication company)</li><li>Strong network and knowledge about the city</li><li>Excellence to bridge, develop and maintain good relationships with key partners such as but not limited to local/regional government stakeholders, 3rd party partners, merchant associations, communities</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Excellent communication skills and proficiency in English</li><li>Experienced in managing a big team, as well as strong in people development and mentoring / coaching would be a plus point</li><li>Fact-based/number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Region Merchant Development Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">Regional Merchant Engagement Manager has the responsibility to develop the assigned regional market by creating strategies to keep merchants within the region actively engaged and have their revenue grown. This role reports to Regional Sales Senior Manager.</span></div>","descriptionBodyPlain":"About The Role\n\nRegional Merchant Engagement Manager has the responsibility to develop the assigned regional market by creating strategies to keep merchants within the region actively engaged and have their revenue grown. This role reports to Regional Sales Senior Manager.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ea0f2d5a-c9d5-4202-ac91-a671b128bfb4","applyUrl":"https://jobs.lever.co/GoToGroup/ea0f2d5a-c9d5-4202-ac91-a671b128bfb4/apply"},{"additionalPlain":"You will spend 50%-60% of your working hours on analysis and dashboard creation. The remaining is for presentation, coordination, team development and others. You will join a large team (over 50 members) with many moving parts. You are here to help simplify the complexity.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 16px\">You will spend 50%-60% of your working hours on analysis and dashboard creation. The remaining is for presentation, coordination, team development and others. You will join a large team (over 50 members) with many moving parts. You are here to help simplify the complexity.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714965919146,"descriptionPlain":"About The Role\n\nRegion Operations Associate is an in-house consultant within our regional operations team. You will gain wide access to Gojek’s gigantic database in order to generate various types of analysis, proposals and business dashboards. Everyday can be different in this role. This role seeks individuals who are comfortable facing different issues everyday.\n\nIn this role you will answer and create data dashboards for various questions such as: \n1. “How should we define driver service quality and how to measure it?”\n2. “How to detect if there is any anomaly in the dataset?”\n3. “Which city has been underperforming, why, and how can we address it?”\n\n\n\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Region Operations Associate is an in-house consultant within our regional operations team. You will gain wide access to Gojek’s gigantic database in order to generate various types of analysis, proposals and business dashboards. Everyday can be different in this role. This role seeks individuals who are comfortable facing different issues everyday.</span></div><div><br></div><div><span style=\"font-size: 16px\">In this role you will answer and create data dashboards for various questions such as:&nbsp;</span></div><div><span style=\"font-size: 16px\">1. “How should we define driver service quality and how to measure it?”</span></div><div><span style=\"font-size: 16px\">2. “How to detect if there is any anomaly in the dataset?”</span></div><div><span style=\"font-size: 16px\">3. “Which city has been underperforming, why, and how can we address it?”</span></div><div><br></div><div><br></div><div><br></div>","id":"29c083cb-0dda-4ce1-9513-788f00e8f482","lists":[{"text":"What You Will Do:","content":"<li>Answer consultant-level questions such as “how can we increase adoption rate of a driver apps feature from x% to y% within 3 months?” and “how can we create profiling segments for millions of Gojek accounts”</li><li>Build fairly complex quantitative model to help predict business outcome</li><li>Write fairly complex SQL query on daily basis</li><li>Create user-friendly dashboards with softwares such as Metabase or Tableau</li><li>Assist the Regional Operations Manager to coordinate implementation of initiatives across cities</li><li>Teach and coach the city-level team members on how to do business analytics</li>"},{"text":"What You Will Need:","content":"<li>At least 2-5 years of relevant analytics role, preferably from consulting firms and technology companies or any institutions with complex and large database</li><li>Quantitative academic degrees e.g. engineering, mathematics, economics with&nbsp;strong academic record (GPA &gt;3.5)</li><li>Strong in SQL query, dashboard creation, and structured problem-solving</li><li>Experience in using data analytic tools like BigQuery, Tableau, Metabase</li><li>Proficient English (you will read a lot of technical documentation written in English)</li><li>Go getter personality (when there is blocker you must find your way around it, including having to do ground visit and interviewing drivers when necessary)</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Region Operations Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Region Operations Associate is an in-house consultant within our regional operations team. You will gain wide access to Gojek’s gigantic database in order to generate various types of analysis, proposals and business dashboards. Everyday can be different in this role. This role seeks individuals who are comfortable facing different issues everyday.</span></div><div><br></div><div><span style=\"font-size: 16px;\">In this role you will answer and create data dashboards for various questions such as:&nbsp;</span></div><div><span style=\"font-size: 16px;\">1. “How should we define driver service quality and how to measure it?”</span></div><div><span style=\"font-size: 16px;\">2. “How to detect if there is any anomaly in the dataset?”</span></div><div><span style=\"font-size: 16px;\">3. “Which city has been underperforming, why, and how can we address it?”</span></div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About The Role\n\nRegion Operations Associate is an in-house consultant within our regional operations team. You will gain wide access to Gojek’s gigantic database in order to generate various types of analysis, proposals and business dashboards. Everyday can be different in this role. This role seeks individuals who are comfortable facing different issues everyday.\n\nIn this role you will answer and create data dashboards for various questions such as: \n1. “How should we define driver service quality and how to measure it?”\n2. “How to detect if there is any anomaly in the dataset?”\n3. “Which city has been underperforming, why, and how can we address it?”\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/29c083cb-0dda-4ce1-9513-788f00e8f482","applyUrl":"https://jobs.lever.co/GoToGroup/29c083cb-0dda-4ce1-9513-788f00e8f482/apply"},{"additionalPlain":"About The Team\n\nAs an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">As an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713428751727,"descriptionPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","description":"<div><b style=\"font-size: 10pt\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","id":"0489939a-c571-4d5f-adaa-95ceac8912c5","lists":[{"text":"What You Will Do: ","content":"<li>Responsible for completed orders and profit and loss target achievement</li><li>Provide analytics to support operations team such as Supply Reliability, Fraud rules, Driver’s Engagement etc. at the regional level</li><li>Deploy defined strategies from operations perspective during the process of establishing the new area of service as well as optimizing existing area</li><li>Ensure SOP and legal compliances in the region</li><li>Support Regional Operation Head to oversee all districts and branches operations</li><li>Analyze driver states &amp; measure efficiency of various driver badges to generate more high quality drivers in the region</li><li>Support Regional Operation Head in product changes roll out in the region</li>"},{"text":"What You Will Need:","content":"<li>Having at least 5 years experience in supply chain, preferably at the managerial level and from Multi National Company or similar experience in the Ride Hailing/ On Demand Service Industry</li><li>Strong analytical thinking and problem solving skills using various improvement tools and methods (preferably have prior exposure to SQL)</li><li>Having good understanding about supply and demand planning</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Lead team / project as well as persuade stakeholders to ensure speed &amp; quality of project / initiative</li><li>Proficiency in to converse in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Region Operations Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","descriptionBodyPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5","applyUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5/apply"},{"additionalPlain":"About the Team\n\nFood Pod Research Team consists of a tight-knit group made up of researchers with different backgrounds and interests. Currently, our team has been busy working on elevating Food Business to the next level in Indonesia and Vietnam. We welcome those who are passionate about exploring trending food with us in Blok M or trying out different sports activities (squash, tennis, yoga, pilates, swimming, running, dancing, muay Thai, softball, what’s next?)\n\n\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Food Pod Research Team consists of a tight-knit group made up of researchers with different backgrounds and interests. Currently, our team has been busy working on elevating Food Business to the next level in Indonesia and Vietnam. We welcome those who are passionate about exploring trending food with us in Blok M or trying out different sports activities (squash, tennis, yoga, pilates, swimming, running, dancing, muay Thai, softball, what’s next?)</div><div><br></div><div><br></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718797510615,"descriptionPlain":"About the Role \n\nThey say no man is an island, and this notion holds particularly true for this role. As our market researcher, you’ll be an instrumental cog in the OneTransport Research at Gojek that directly impacts the company’s direction and decision on strategies, products to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to stakeholders. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Marketing and Strategy teams will be your main companion during this ride. Best yet, you’ll have the opportunity to flex your quantitative, and qualitative research skills, getting us even closer as a thinking partner and navigator for our stakeholders.\n\n","description":"<div>About the Role </div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our market researcher, you’ll be an instrumental cog in the OneTransport Research at Gojek that directly impacts the company’s direction and decision on strategies, products to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to stakeholders. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Marketing and Strategy teams will be your main companion during this ride. Best yet, you’ll have the opportunity to flex your quantitative, and qualitative research skills, getting us even closer as a thinking partner and navigator for our stakeholders.</div><div><br></div>","id":"850a3da9-a054-4ef9-981d-d0c0157a18c1","lists":[{"text":"What You Will Do","content":"<li>Do research projects for Food ecosystems (customers, merchants, drivers) to come up with actionable insights for product &amp; business development, such as product concept testing, usability testing, post-launch evaluation study, brand health tracking, pricing study, etc</li><li>Build relationships with stakeholders (Product, Design, Strategic &amp; Planning, &amp; Marketing team) and understand their business objectives and translate it into relevant research questions</li><li>Build research plan (including ensuring objectives, determining sample design, frameworks, timeline, and what method to use) with medium-low supervision from the manager</li><li>Collect and analyze data using a variety of research methods, including surveys, interviews, FGD, and data exploration with medium-low supervision</li><li>Present research findings and recommendations to stakeholders in reports and presentations</li><li>Collaborating with diverse stakeholders and effectively communicating research findings to non-technical teams.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of consumer/market research experience. Prior exposure to working in a top-tier market research agency/consultant firm&nbsp; and/or Product research projects is a plus</li><li>Experience in both quantitative &amp; qualitative research, and have a good understanding of the Indonesian market and culture</li><li>Experience in projects with strategic focus like segmentation, usage &amp; attitude, brand health tracking, and complex product launch is an advantage</li><li>Strong analytical thinking skills and the aptitude to pick up new skills quickly</li><li>Good communication and language skills in Bahasa and English (writing &amp; speaking)</li><li>Proven effective project management skill, communication skill, and strategic thinking capability with an orientation to detail</li><li>Confident and comfortable facing, influencing, and getting buy-in from internal &amp; external stakeholders in day-to-day activities</li><li>A desire to work in a fast-paced environment with a dedicated commitment. A self-motivator for learning, problem-solving, and deep-diving into complex concepts</li>"}],"text":"Researcher - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role </div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our market researcher, you’ll be an instrumental cog in the OneTransport Research at Gojek that directly impacts the company’s direction and decision on strategies, products to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to stakeholders. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Marketing and Strategy teams will be your main companion during this ride. Best yet, you’ll have the opportunity to flex your quantitative, and qualitative research skills, getting us even closer as a thinking partner and navigator for our stakeholders.</div><div><br></div>","descriptionBodyPlain":"About the Role \n\nThey say no man is an island, and this notion holds particularly true for this role. As our market researcher, you’ll be an instrumental cog in the OneTransport Research at Gojek that directly impacts the company’s direction and decision on strategies, products to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to stakeholders. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Marketing and Strategy teams will be your main companion during this ride. Best yet, you’ll have the opportunity to flex your quantitative, and qualitative research skills, getting us even closer as a thinking partner and navigator for our stakeholders.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/850a3da9-a054-4ef9-981d-d0c0157a18c1","applyUrl":"https://jobs.lever.co/GoToGroup/850a3da9-a054-4ef9-981d-d0c0157a18c1/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719311524375,"description":"","descriptionPlain":"","id":"50c98a4b-fda9-41ec-8e33-28f996cdc291","lists":[{"text":"What You Will Do","content":"<li>Do product &amp; market research projects for transport products for both customers and drivers: usage and attitude study, usability testing, market sizing, concept testing, market analysis, etc</li><li>Build relationships with stakeholders and understand their research questions by attending/initiating meetings that are related to your stakeholders</li><li>Build a research plan (including ensuring objectives, determining sample design, frameworks, timeline, and what method to use) with medium-low supervision from the manager</li><li>Collect and analyze data using various research methods, including surveys, interviews, focus groups, and data exploration with medium-low supervision</li><li>Present research findings and recommendations to stakeholders in presentations, reports, and meetings</li><li>Collaborating with diverse stakeholders and effectively communicating research findings to non-technical teams.</li>"},{"text":"What You Will Need","content":"<li>Data-Driven Decision Making: prioritize using data to inform their decisions, relying on thorough analysis to guide strategies and actions</li><li>Critical Thinking: Encouraged to question assumptions, identify patterns, and draw insightful conclusions from complex data sets (both qualitative and quantitative)</li><li>Rigorous Techniques: Employ established and reliable research methods to ensure the accuracy and reliability of findings. Plus points if being familiar with both Qualitative and Quantitative techniques</li><li>Comprehensive Data Collection: Gather data from diverse sources to build a well-rounded understanding of the research subject</li><li>Creative Problem-Solving: looking for ideas elsewhere and thinking outside the box when necessary, exploring multiple perspectives to problem-solving</li><li>Rapid Adaptation: should be able to quickly adjust to changing project requirements, market trends, and unexpected challenges</li><li>Project management skill: structured planning, smooth communication, neat filing, good time management, good team collaborator</li><li>Finds doing research, discussion, and brainstorming as fun activities! :)&nbsp;</li>"}],"text":"Researcher - Mobility","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/50c98a4b-fda9-41ec-8e33-28f996cdc291","applyUrl":"https://jobs.lever.co/GoToGroup/50c98a4b-fda9-41ec-8e33-28f996cdc291/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718002291914,"descriptionPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","description":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","id":"f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","lists":[{"text":"What You Will Do","content":"<li>Monitor and analyze transactions and user activities to detect suspicious patterns and potential fraud.</li><li>Conduct thorough investigations of suspected fraud cases and recommend control actions.</li><li>Develop and implement strategies to mitigate fraud risks across the platform.</li><li>Collaborate with product, engineering, and operations teams to enhance fraud prevention measures.</li><li>Prepare detailed reports on fraud incidents, including root cause analysis and actionable recommendations.</li><li>Provide regular updates to senior management on fraud trends, risks, and mitigation efforts.</li><li>Stay updated on the latest fraud trends, tools, and best practices to continuously improve detection and prevention strategies.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Finance, Accounting, Business, Computer Science, or a related field.</li><li>2+ years of experience in fraud risk management or a related role.</li><li>Strong analytical and problem-solving skills, with proficiency in data analysis tools (e.g. SQL, Python, Excel) and experience with visualization tools (e.g. Tableau, DataStudio)</li><li>Excellent communication and interpersonal skills.</li><li>Ability to work independently and as part of a team in a fast-paced environment.</li><li>Strong attention to detail and commitment to accuracy.</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Risk Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","descriptionBodyPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","applyUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710738954272,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"60d37414-287e-4552-a0d0-accf1737d0ce","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>3-4 years of related payment risk experience, preferably on the acquiring side and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business side</li>"}],"text":"Risk Analyst - Payments #9984","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce","applyUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce/apply"},{"additionalPlain":"In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1704856901936,"description":"","descriptionPlain":"","id":"5611e062-e094-4da3-ab1c-75c85cf62194","lists":[{"text":"What You Will Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volumes of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutions, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers&nbsp;</li>"},{"text":"What you will need","content":"<li>3+ years of experience developing ML solutions</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Risk Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194","applyUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713334327811,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"a61cda6c-82fd-4daf-aabf-3db91e01684f","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>5-8 years of related payment risk experience, preferably on the mobile apps and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business sid</li>"}],"text":"Risk Manager - Payments #9868","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f","applyUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f/apply"},{"additionalPlain":"About The Team\n\n- The Risk Strategy Team already attracts talents with in-depth experience in consumer lending risk management\n- Team members are from diverse background and cultures, providing a open and inclusive environment to develop\n- The working style in the team is productive and outcome-driven\n- The business is now in the expansion stage, and all the team members will enjoy great exposure to the credit business and ToB life-cycle risk management process\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>- The Risk Strategy Team already attracts talents with in-depth experience in consumer lending risk management</div><div>- Team members are from diverse background and cultures, providing a open and inclusive environment to develop</div><div>- The working style in the team is productive and outcome-driven</div><div>- The business is now in the expansion stage, and all the team members will enjoy great exposure to the credit business and ToB life-cycle risk management process</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713511923769,"description":"","descriptionPlain":"","id":"e318ec15-ebfb-44d7-a6f0-c1d1b3cc9e59","lists":[{"text":"What You Will Do","content":"<li>Perform underwriting and post-loan management data analysis, output policy decisions based on it, actively monitor results, and effectively iterate the policies</li><li>Conduct user segmentation, pricing sensitivity check &amp; risk-based pricing on consumer lending products</li><li>Analyze user behaviors in the ecosystem, do problem-solving, and provide proposals to the management on risk control, UX improvement, and onboarding channel management&nbsp;</li><li>Prepare Risk reporting, position reporting, monitoring dashboards, and present recommendations</li><li>Support credit business growth by defining &amp; analyzing possible risks and consequences, and designing processes to eliminate and mitigate</li><li>Work closely with other business stakeholders and share insights of risk management</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal &amp; external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL, if proficient will be a big advantage. Python is a bonus item</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Risk Strategy - Consumer Lending #9919","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/e318ec15-ebfb-44d7-a6f0-c1d1b3cc9e59","applyUrl":"https://jobs.lever.co/GoToGroup/e318ec15-ebfb-44d7-a6f0-c1d1b3cc9e59/apply"},{"additionalPlain":"About The Team\n\n- The Risk Strategy Team already attracts talents with in-depth experience in consumer lending risk management\n- Team members are from diverse background and cultures, providing a open and inclusive environment to develop\n- The working style in the team is productive and outcome-driven\n- The business is now in the expansion stage, and all the team members will enjoy great exposure to the credit business and ToB life-cycle risk management process\n","additional":"<div><b>About The Team</b></div><div><br></div><div>- The Risk Strategy Team already attracts talents with in-depth experience in consumer lending risk management</div><div>- Team members are from diverse background and cultures, providing a open and inclusive environment to develop</div><div>- The working style in the team is productive and outcome-driven</div><div>- The business is now in the expansion stage, and all the team members will enjoy great exposure to the credit business and ToB life-cycle risk management process</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1715764385486,"description":"","descriptionPlain":"","id":"e33b73ae-63e2-4e9c-aff9-03e9127e4e4e","lists":[{"text":"What You Will Do","content":"<li>Perform underwriting and post-loan management data analysis, output policy decisions based on it, actively monitor results, and effectively iterate the policies</li><li>Conduct user segmentation, pricing sensitivity check &amp; risk-based pricing on consumer lending products</li><li>Analyze user behaviors in the ecosystem, do problem-solving, and provide proposals to the management on risk control, UX improvement, and onboarding channel management&nbsp;</li><li>Prepare Risk reporting, position reporting, monitoring dashboards, and present recommendations</li><li>Support credit business growth by defining &amp; analyzing possible risks and consequences, and designing processes to eliminate and mitigate</li><li>Work closely with other business stakeholders and share insights of risk management</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal &amp; external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL, if proficient will be a big advantage. Python is a bonus item</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Risk Strategy - Consumer Lending #9919","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/e33b73ae-63e2-4e9c-aff9-03e9127e4e4e","applyUrl":"https://jobs.lever.co/GoToGroup/e33b73ae-63e2-4e9c-aff9-03e9127e4e4e/apply"},{"additionalPlain":"About The Team\n\nStep into our dynamic team– a powerhouse of talent, crafting strategies that drive impact at scale in the nation's booming digital economy. Imagine: each of us is like a unique puzzle piece, coming together to form a cohesive vision for success. From strategy to execution, we're a well-oiled machine, working seamlessly to empower Gojek’s nationwide sales team.\nBut it's not just about work. We believe in fostering joy and connection, whether over a meal or through shared laughter. Working with us means guidance and support, while maintaining your independence and flexibility. Together, we'll navigate challenges and seize opportunities, all while empowering Indonesians to face the digital revolution forward.\nReady to join a team shaping the future of sales strategy and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Step into our dynamic team– a powerhouse of talent, crafting strategies that drive impact at scale in the nation's booming digital economy. Imagine: each of us is like a unique puzzle piece, coming together to form a cohesive vision for success. From strategy to execution, we're a well-oiled machine, working seamlessly to empower Gojek’s nationwide sales team.</span></div><div><span style=\"font-size: 10pt\">But it's not just about work. We believe in fostering joy and connection, whether over a meal or through shared laughter. Working with us means guidance and support, while maintaining your independence and flexibility. Together, we'll navigate challenges and seize opportunities, all while empowering Indonesians to face the digital revolution forward.</span></div><div><span style=\"font-size: 10pt\">Ready to join a team shaping the future of sales strategy and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710312757111,"descriptionPlain":"About The Role\n\nJoin our team and make a real impact. As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with sales, business, product, and marketing teams, you'll devise winning strategies that drive maximum value for the company. Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">Join our team and make a real impact. As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with sales, business, product, and marketing teams, you'll devise winning strategies that drive maximum value for the company. Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","id":"a5f5f567-0e95-4763-8c50-c4dcfb0b757e","lists":[{"text":"What You Will Do","content":"<li>Develop comprehensive sales strategies and oversee the end-to-end planning process to ensure optimal results while maintaining efficiency levels.</li><li>Define Objectives and Key Results (OKRs), metrics, and targets for the sales team to drive performance and success.</li><li>Design and implement incentive schemes, conduct end-to-end calculations, and perform industry benchmarking to enhance sales effectiveness.</li><li>Lead the go-to-market sales strategy for special projects and new products, aligning with partner needs and market demands.</li><li>Utilize data-driven analysis to derive actionable insights, fostering accelerated growth and increased operational efficiency.</li><li>Collaborate cross-functionally with product, marketing, sales, and other stakeholders to align strategies derived from data-driven analysis and execute plans effectively.</li><li>Represent the Sales Strategy team in industry events, trainings, and workshops as necessary&nbsp;Provide regular and ad-hoc impact reports and analyses to senior management, offering insights into performance and growth opportunities for the business.</li>"},{"text":"What You Will Need","content":"<li>4 years+ relevant working experience in strategy,&nbsp; business development, management consulting or other related roles that require strong analytical skills, problem-solving, and business acumen</li><li>A structured and analytical thinking process to develop frameworks, project charters and prioritization</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Proficiency in basic modeling - market sizing, business projection, scenario analysis.</li><li>Have good presentation skills - esp. the ability to present during problem solving session with other stakeholders (working-level or leadership)&nbsp;</li><li>Solid track record of stakeholder management</li><li>Proficiency in SQL/query is preferred, but not mandatory (still essential in executing the role, and will need to learn basic SQL on-the-job)</li>"}],"text":"Sales Strategy Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">Join our team and make a real impact. As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with sales, business, product, and marketing teams, you'll devise winning strategies that drive maximum value for the company. Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","descriptionBodyPlain":"About The Role\n\nJoin our team and make a real impact. As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with sales, business, product, and marketing teams, you'll devise winning strategies that drive maximum value for the company. Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a5f5f567-0e95-4763-8c50-c4dcfb0b757e","applyUrl":"https://jobs.lever.co/GoToGroup/a5f5f567-0e95-4763-8c50-c4dcfb0b757e/apply"},{"additionalPlain":"The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood campaigns.\n\nIn the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales team.When our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their efficiency.\n\nIn our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood </span><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">campaigns.</span></a></div><div><br></div><div><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales </span><a href=\"http://team.When\" class=\"postings-link\"><span style=\"font-size: 10pt\">team.When</span></a><span style=\"font-size: 10pt\"> our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their </span><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">efficiency.</span></a></div><div><br></div><div><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Excellence","allLocations":["Jakarta"]},"createdAt":1714365620212,"descriptionPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","description":"<div><span style=\"font-size: 10pt\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","id":"f39be622-e287-41df-bcb2-7389478a1be4","lists":[{"text":"What you will do","content":"<li>Oversee the performance tracking and monitoring of the whole Enterprise Sales Team</li><li>Ensure that the Enterprise Sales team has all the data they need to achieve their target for all KRs</li><li>Act as a consultant and discuss with the EKAMs on the business needs/challenges that their merchants are facing</li><li>Provide data and data driven insights to EKAMs to help address said challenges</li><li>Assist in performing periodical business analysis, tailored to each merchant based on their business needs</li><li>Assist in the daily tasks and smooth operations of Enterprise Sales Support</li><li>Liaise with HO team for merchant x sales account management, target, tracker, etc</li><li>Liaise with other teams (e.g. BI, Salestech) when there is new KRs / data point that needs to be analysed</li><div><br></div>"},{"text":"What you will need","content":"<li>At least 2 years of relevant experience in data analytics&nbsp;</li><li>Good business acumen, able to develop analysis with good storyline and flow</li><li>Proficient in SQL, Google BigQuery and the reporting thereof is an advantage</li><li>Proficient in handling large amount of data using tools/softwares such as google sheet, metabase and datastudio</li><li>Great communication and understanding skill, able to explain technical terms in simple, understandable manner</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>High interest and eagerness to analyse different parts of businesses to help achieve growth</li><li>Clear understanding of Gojek services and the tech industry</li><div><br></div>"}],"text":"Sales Support Senior Associate, Enterprise","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","descriptionBodyPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4","applyUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4/apply"},{"additionalPlain":"About The Team\n\nWe are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success\n\nWe're a highly flexible team with a target-driven mindset. We manage our work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>We are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success</div><div><br></div><div>We're a highly flexible team with a target-driven mindset. We manage our work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1713924868065,"descriptionPlain":"About The Role\n\nWe are seeking a talented individual to oversee and ensure smooth operations in the Moka sales process. As the Sales Support Specialist, you will be responsible for maintaining sales tools for the Moka sales team, acting as a point of contact to develop special arrangements in agreement between sales and merchants through liaising with the legal team, maintaining sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual to oversee and ensure smooth operations in the Moka sales process. As the Sales Support Specialist, you will be responsible for maintaining sales tools for the Moka sales team, acting as a point of contact to develop special arrangements in agreement between sales and merchants through liaising with the legal team, maintaining sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","id":"9377622b-e5b4-4cd1-a5b0-8432c9ef5808","lists":[{"text":"What You Will Do","content":"<li>Lead, motivate, and manage the sales support team to ensure they provide the best possible support to sales team and merchants</li><li>Develop and implement procedures for effective sales support administration</li><li>Ensure all sales inquiries and issues are addressed promptly and accurately, with a focus on improving merchant satisfaction and topline sales metrics</li><li>Coordinate with the merchant sales team to streamline sales processes and remove obstacles in the sales cycle&nbsp;</li><li>Manage and maintain accurate sales records and reports for senior management review</li><li>Collaborate with other departments to ensure sales strategies are aligned and support the overall goals of the organization</li><li>Assist in the development and implementation of sales policies and practices that drive sales effectiveness</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Business Administration, Marketing, or a related field</li><li>Minimum of 3 years of experience in sales support, account management, customer service, or a supervisory role within a sales-focused organization</li><li>Good command of reporting skills (Google Sheets, etc), strong customer/ merchant partner focus, and project management skills preferred</li><li>Strong analytical and problem-solving abilities</li><li>Detail and deadline-oriented, strong stakeholder management and cross-functional collaboration</li>"}],"text":"Sales Support Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual to oversee and ensure smooth operations in the Moka sales process. As the Sales Support Specialist, you will be responsible for maintaining sales tools for the Moka sales team, acting as a point of contact to develop special arrangements in agreement between sales and merchants through liaising with the legal team, maintaining sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a talented individual to oversee and ensure smooth operations in the Moka sales process. As the Sales Support Specialist, you will be responsible for maintaining sales tools for the Moka sales team, acting as a point of contact to develop special arrangements in agreement between sales and merchants through liaising with the legal team, maintaining sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9377622b-e5b4-4cd1-a5b0-8432c9ef5808","applyUrl":"https://jobs.lever.co/GoToGroup/9377622b-e5b4-4cd1-a5b0-8432c9ef5808/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1698657930091,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"376aefd9-6d6c-4e57-8040-a3b0dd416d26","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2 to 4 years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26","applyUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719471574933,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2-4+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","applyUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9/apply"},{"additionalPlain":"About our Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About our Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1700733541559,"descriptionPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","description":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","id":"472ae629-87cb-4f8c-bb69-eae35cf3751e","lists":[{"text":"What you’ll do","content":"<li>Develop and implement test automation tools and frameworks to ensure continuous testing of product features</li><li>Collaborate with product managers and engineers to understand requirements, document test cases, and define rollout/release strategies</li><li>Perform performance, load, and scalability testing for new features and product releases.</li><li>Debug and diagnose defects uncovered during testing to determine root causes. Log bugs accurately and communicate issues clearly to engineering teams</li><li>Monitor systems in production to identify and troubleshoot defects or anomalous behavior.</li><li>Stay up-to-date with new testing methodologies and tools</li><div><br></div><div><br></div>"},{"text":"What you’ll need","content":"<li>5+ years experience in a QA, SDET or DevX role, with expertise in test automation</li><li>Proficiency with one or more programming languages like Java, Go, Kotlin, Python</li><li>Experience testing complex distributed systems and microservices architectures</li><li>Understanding of SQL and NoSQL databases</li><li>Familiarity with technologies like Kafka, Docker, Kubernetes</li><li>Knowledge of financial systems, mobile apps, or SaaS products is a plus</li><li>Excellent verbal and written communication skills</li>"}],"text":"SDET - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e","applyUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div>","categories":{"commitment":"Permanent","department":"Fintech - Consumer Payments","location":"Bengaluru","team":"Consumer Experience","allLocations":["Bengaluru"]},"createdAt":1716277072995,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"0169bd4d-f352-4162-8e8e-2c09df5b8db4","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Growth (Bangalore)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4","applyUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div>","categories":{"commitment":"Permanent","department":"Fintech - Consumer Payments","location":"Jakarta","team":"Consumer Experience","allLocations":["Jakarta"]},"createdAt":1716293425375,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"7b320e00-3745-4478-8097-93405566819d","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Growth (Jakarta)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7b320e00-3745-4478-8097-93405566819d","applyUrl":"https://jobs.lever.co/GoToGroup/7b320e00-3745-4478-8097-93405566819d/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present and long term.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present and long term.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"Fintech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1718728602647,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"2185e0b2-1f04-4aef-b83b-42f6fc2b44d0","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Payments Tooling (Bangalore)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2185e0b2-1f04-4aef-b83b-42f6fc2b44d0","applyUrl":"https://jobs.lever.co/GoToGroup/2185e0b2-1f04-4aef-b83b-42f6fc2b44d0/apply"},{"additionalPlain":"About the Team \n\nMxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).\n\nCore areas that we focus on - \nDeveloper Experience and Tooling: We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.\n\nFoundation and Building Blocks: This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!\n\nApp Excellence and Insights Tooling: The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">MxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).</span></div><div><br></div><div><b style=\"font-size: 16px\">Core areas that we focus on - </b></div><div><b style=\"font-size: 16px\">Developer Experience and Tooling: </b><span style=\"font-size: 16px\">We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.</span></div><div><br></div><div><b style=\"font-size: 16px\">Foundation and Building Blocks:</b><span style=\"font-size: 16px\"> This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!</span></div><div><br></div><div><b style=\"font-size: 16px\">App Excellence and Insights Tooling: </b><span style=\"font-size: 16px\">The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697010103248,"descriptionPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","id":"3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","lists":[{"text":"What You Will Do ","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need ","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Android Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px;\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","applyUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. \n\nWe want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines. We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><span style=\"font-size: 16px\">About The Team</span></div><div><br></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. </span></div><div><br></div><div><span style=\"font-size: 16px\">We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines. We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression </span><b style=\"font-size: 16px\">😎</b><span style=\"font-size: 16px\"> If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div>","categories":{"department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718078207662,"descriptionPlain":"About The Role\n\nThe Senior Copywriter role presents a dynamic challenge that blends creativity with strategic communication. As a key member of the team, this role will be tasked with crafting compelling narratives and messaging across various platforms to engage our target audience effectively. The scope of this role involves conceptualizing and executing creative campaigns in collaboration with the Art Director, ensuring alignment with our brand identity and marketing objectives. Challenges may include maintaining consistency in messaging while adapting to diverse marketing channels and audience preferences.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">The Senior Copywriter role presents a dynamic challenge that blends creativity with strategic communication. As a key member of the team, this role will be tasked with crafting compelling narratives and messaging across various platforms to engage our target audience effectively. The scope of this role involves conceptualizing and executing creative campaigns in collaboration with the Art Director, ensuring alignment with our brand identity and marketing objectives. Challenges may include maintaining consistency in messaging while adapting to diverse marketing channels and audience preferences.</span></div>","id":"2ef0e64a-0119-4601-9d7c-686c9301090a","lists":[{"text":"What You Will Do","content":"<li>Collaborate with the Art Director to develop and execute creative concepts for 360 marketing campaigns, including creative compelling narratives and stories for video and visual campaign ads, ensuring synergy between copy and visuals</li><li>Write clear, concise, and persuasive copy for various marketing materials, including advertisements, and other supporting marketing channels</li><li>Edit and proofread copy to ensure accuracy, consistency, and adherence to brand guidelines</li><li>Contribute to bringing creative ideas and concepts during brainstorming sessions and team meetings</li><li>Manage multiple projects simultaneously and meet deadlines in a fast-paced environment</li>"},{"text":"What You Will Need","content":"<li>You have at least 5 years as a Copywriter or a similar role in creative agency or marketing department</li><li>Creativity and the ability to generate original ideas while also collaborating effectively within a team</li><li>Strong communication skills and the ability to effectively articulate ideas and concepts</li><li>Adaptability and a willingness to embrace feedback and iterate on ideas</li><li>Passionate for storytelling and a deep understanding of branding and marketing principles</li>"}],"text":"Senior Copywriter","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">The Senior Copywriter role presents a dynamic challenge that blends creativity with strategic communication. As a key member of the team, this role will be tasked with crafting compelling narratives and messaging across various platforms to engage our target audience effectively. The scope of this role involves conceptualizing and executing creative campaigns in collaboration with the Art Director, ensuring alignment with our brand identity and marketing objectives. Challenges may include maintaining consistency in messaging while adapting to diverse marketing channels and audience preferences.</span></div>","descriptionBodyPlain":"About The Role\n\nThe Senior Copywriter role presents a dynamic challenge that blends creativity with strategic communication. As a key member of the team, this role will be tasked with crafting compelling narratives and messaging across various platforms to engage our target audience effectively. The scope of this role involves conceptualizing and executing creative campaigns in collaboration with the Art Director, ensuring alignment with our brand identity and marketing objectives. Challenges may include maintaining consistency in messaging while adapting to diverse marketing channels and audience preferences.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2ef0e64a-0119-4601-9d7c-686c9301090a","applyUrl":"https://jobs.lever.co/GoToGroup/2ef0e64a-0119-4601-9d7c-686c9301090a/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1707296213776,"description":"","descriptionPlain":"","id":"f680021a-b5cc-43ea-a048-255827353a92","lists":[{"text":"What You Will Do?","content":"<li>Create business impact by working on strategic initiatives in Gojek focussed on analysis and experimentation.&nbsp;</li><li>Build &amp; maintain dashboards for tracking business performance and product adoption.</li><li>Deliver insight, analysis using statistical tools, data visualization, and business use case to product and business team.</li><li>Partner closely with Product Managers and Business teams to help them make decisions.</li><li>Handle Gojek Product and Business team in identifying product or business opportunities and support in product delivery such as experimentation.</li><li>Automate data extraction by creating denormalized tables or data mart based on business or product requirement.</li>"},{"text":"What You Will Need?","content":"<li>At least 3 years of working experience with basic statistics or product analytics. Furthermore with a strong business sense and data-driven role background</li><li>Expert in SQL , data visualization and dashboarding .&nbsp;</li><li>Comfortable working both independently with minimal guidance and in a team setting</li><li>Ability to use critical thinking daily to manage daily tasks while being goal-oriented</li><li>Ability to transform an ambiguous business or product problem into a well-scoped and impactful analysis; able to design simple experiments</li><li>Exposure to visualization and dashboarding tools like&nbsp; &nbsp;Tableau, Metabase, Google Data Studio, Clevertap, Python, etc is a plus.</li>"},{"text":"About The Team","content":"<li>Our Data Analyst team currently consists of 40+ people based in India and Indonesia who run Southeast Asia’s leading Gojek business. We oversee all things data and work to become a thought partner for our Business Users, Product Team, and Decision Makers. It’s our job to ensure that they have a structural approach to data-driven problem-solving. Right now, our focus revolves: how to make customers, drivers, and merchants happy and delighted. We have so far created millions of dollar impact across different journeys of customers, drivers and merchants</li><div><br></div><li>We work with the PMs hand-in-glove - be it constructing a new machine learning solution or brainstorming on a problem like how do we reduce the wait time for the drive, how do we improve assortment, should we treat convenience seeking customer differently from value seeking customer etc</li><div><br></div><li>As a team, we’re concerned not only with the growth of the company, but each other’s personal and professional growths, too. Along with us coming from diverse backgrounds, we often have fun sessions to talk about everything and anything from data information to our current movie list.</li><div><br></div>"}],"text":"Senior Data Analyst - India","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/f680021a-b5cc-43ea-a048-255827353a92","applyUrl":"https://jobs.lever.co/GoToGroup/f680021a-b5cc-43ea-a048-255827353a92/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719213882004,"descriptionPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","description":"<div><b style=\"font-size: 10pt\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","id":"1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","lists":[{"text":"What you will do","content":"<li><b>Design, build, and maintain the ETL </b>from various sources into the data mart; Troubleshoot and resolve data-related issues, including data discrepancies, anomalies, and performance bottlenecks</li><li>End to end data project ownership and collaboration with cross-functional teams to understand data requirements and design data models that support the organization's single version of truth</li><li>Ensure the quality, accuracy, and reliability of our data by implementing data validation checks and error handling mechanisms</li><li>Develop and customize Tableau/Google Sheet/Looker studio reports that provide actionable insights to stakeholders</li><li>Create and maintain documentation related to data structures, processes, and transformations for future reference</li>"},{"text":"What you will need","content":"<li>4 years of experience in <b>Data Analyst/BI Analyst/</b>BI Engineer</li><li>Advance knowledge of <b>SQL </b>and Python</li><li>Able to lead a small team also can work as a individual contributor</li><li>Hands on experience with data visualization Tableau Looker studio/Google Sheet</li><li>Strong analytical and problem-solving skills, with keen attention to detail</li><li>Excellent communication skills (English is a must) to collaborate with technical and non-technical stakeholders</li><li>Having a people manager experience is a plus</li>"}],"text":"Senior Data Analyst (Analytics Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","descriptionBodyPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","applyUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264950378,"description":"","descriptionPlain":"","id":"73e71b86-d53f-4841-92ec-4bd09a0ef479","lists":[{"text":"What You Will Do","content":"<li>explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across the Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs..</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Senior Data Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479","applyUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479/apply"},{"additionalPlain":"Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719472943608,"descriptionPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","description":"<div><span style=\"font-size: 10pt\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","id":"90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","lists":[{"text":"What You Will Do","content":"<li>Design, build, and maintain data streaming solutions.</li><li>Troubleshoot and resolve data-related issues, including discrepancies, anomalies, and performance bottlenecks.</li><li>Ensure scalability and reliability of the data streaming platform.</li><li>Collaborate with data engineers, data scientists, and other stakeholders to understand requirements and provide tailored streaming solutions.</li><li>Monitor and optimise performance to ensure low latency and high throughput.</li><li>Perform regular maintenance tasks, including upgrades and patches.</li><li>Document design, implementation, and maintenance processes.</li><li>Stay updated with the latest advancements in data streaming technologies.</li>"},{"text":"What You Will Need","content":"<li>5+ years of experience as a Data Engineer.</li><li>Strong programming skills in Java.</li><li>Hands-on experience in real-time streaming with Apache Flink.</li><li>Experience working with Apache Kafka and Kubernetes.</li><li>Experience working with any cloud platform and NoSQL database.</li><li>Strong analytical and problem-solving skills, with keen attention to detail.</li><li>Excellent communication skills for collaborating with technical and non-technical stakeholders.</li><li><b>Good to have: </b>Programming in Go/Python, IAC using Terraform, Batching ETL and exposure to open data lakehouse architecture is a plus</li><div><br></div>"}],"text":"Senior Data Engineering - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","descriptionBodyPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","applyUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b/apply"},{"additionalPlain":"About The Team\nThe GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><span style=\"font-size: 10pt\">The GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1684915963454,"descriptionPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","description":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","id":"a539cdc1-109f-48e8-9b24-1a831b735f01","lists":[{"text":"What Will You Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volume of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers</li>"},{"text":"What You Will Need","content":"<li>6+ years of experience developing ML solutions, 2-3 years of <b>fraud risk experience in account takeover, scam, and abuse</b></li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt;\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","descriptionBodyPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01","applyUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1713852044349,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"34f6146a-c482-407c-a31c-72ac9bb90a7c","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>Analyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist - Marketplace (Singapore)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c","applyUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1705993404249,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"86673189-b5e2-4ace-b1a3-5ab20f14d84d","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist (India)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d","applyUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707210044551,"descriptionPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","description":"<div><span style=\"font-size: 10pt\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","id":"c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","lists":[{"text":"What You Will Do","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What You Will Need","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li>"}],"text":"Senior Data Warehouse Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","descriptionBodyPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","applyUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69/apply"},{"additionalPlain":"About The Team\n\nOur Data Warehouse team is based in Jakarta & Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nOur team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data Warehouse team is based in Jakarta &amp; Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1713498805305,"descriptionPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","description":"<div><span style=\"font-size: 10pt\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","id":"2b430ba4-210e-4db6-a63e-c11459a0304f","lists":[{"text":"What Will You Do?","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What Do You Need? ","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li><li>You’re passionate about your customers and always bring questions back to what will serve them best</li>"}],"text":"Senior Data Warehouse Engineer - India","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt;\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","descriptionBodyPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f","applyUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f/apply"},{"additionalPlain":"About the Team\n\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719199384298,"descriptionPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"905d4e32-1699-4fcc-96b3-aa6aa0b462cb","lists":[{"text":"What You Will Do","content":"<li>Analyze database performance data to identify bottlenecks and implement optimizations to enhance system efficiency and reliability</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li><li>Design and develop custom tools and utilities to facilitate various database operations, leveraging programming languages such as Ruby, or Golang</li><li>Ensure database security best practices are implemented and maintained, including access control, encryption, and compliance with relevant regulations</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Continuously evaluate database infrastructure usage and performance metrics to identify opportunities for cost optimization</li><li>Benchmarking tests to evaluate the impact of configuration changes on database performance. This helps in identifying optimal parameter values and fine-tuning configurations for different types of workloads.</li><li>Tuning database configuration parameters to optimize database performance for the application</li>"},{"text":"What You Will Need","content":"<li>8+ years experience as a DBA Engineer in managing databases for a large production environment</li><li>Expert in various database management systems (MySQL/PostgreSQL, Redis, MongoDB, and Elastic Search), and techniques for optimizing databases and understanding the basic cloud platform (AWS or GCP)</li><li>Advanced skills in a programming language like Ruby or Golang, and possess deep expertise in shell scripting</li><li>Excellent experience with Linux is required and expertise in server configuration, maintenance, and troubleshooting</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)</li><li>Proficient in seamlessly conducting database upgrades, ensuring uninterrupted operations and system integrity.</li><li>Proficiency in configuring and utilizing monitoring and diagnostic tools to pinpoint and address database performance issues effectively</li><li>In-depth knowledge of the various configuration parameters tailored to the specific database management system</li>"}],"text":"Senior Database Administrator Engineer - Engineering Platform (Gurgaon)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb","applyUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb/apply"},{"additionalPlain":"About the Team\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719198420770,"descriptionPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"28fe323b-ed5f-482b-b71d-ed60662bed8b","lists":[{"text":"What You Will Do","content":"<li>Develop automation scripts and tools for provisioning, deployment, monitoring, and backup/recovery of databases using infrastructure as code (IaC) principles</li><li>Implement robust monitoring and alerting systems for database performance metrics&nbsp;</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Maintain version-controlled configurations for database servers, ensuring consistency and repeatability across environments via IaC</li><li>Automate routine tasks such as database backups, schema migrations, and data archiving to improve operational efficiency</li><li>Develop database high availability and replication solutions to meet the requirements of critical applications.</li><li>Develop standardized operational procedures within the DBaaS framework to ensure the consistent provision of highly available solutions.</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li>"},{"text":"What You Will Need","content":"<li>5+ years Experience as a DevOps Engineer with a focus on database management</li><li>Hands-on experience with cloud platforms (AWS or GCP)</li><li>Proficiency in scripting languages such as Go, Shell, and Ruby for automation tasks</li><li>Experience with infrastructure as code tools (e.g., Terraform, CloudFormation) for provisioning and managing database resources</li><li>In-depth knowledge of database systems such as MySQL, PostgreSQL, MongoDB, etc., including configuration, optimization, and troubleshooting</li><li>Strong understanding of CI/CD practices and tools</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)&nbsp;</li><li>Experience in configuration management tools (eg: ansible) for database patching and maintenance automation</li>"}],"text":"Senior DevOps Engineer - Engineering Platform (Gurgaon)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b","applyUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1717984515884,"descriptionPlain":"About The Role\n\nAt GoTo Financial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer for the Commerce Enablement group, you’ll be part of the team building some of the most critical products for GoTo Financial merchant-partners. Working alongside some of the brightest minds in the industry across design, product, and engineering, you’ll focus your efforts on designing and implementing products for a massive network of small, medium and large businesses, improving overall application performance, code structure, and developing robust, well-designed software systems. Your ownership, drive, and passion will help provide for a world-class user experience and heightened stability of our Midtrans products, and directly augment the growth of millions of Southeast Asian merchant-partners. \n\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoTo Financial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer for the Commerce Enablement group, you’ll be part of the team building some of the most critical products for GoTo Financial merchant-partners. Working alongside some of the brightest minds in the industry across design, product, and engineering, you’ll focus your efforts on designing and implementing products for a massive network of small, medium and large businesses, improving overall application performance, code structure, and developing robust, well-designed software systems. Your ownership, drive, and passion will help provide for a world-class user experience and heightened stability of our Midtrans products, and directly augment the growth of millions of Southeast Asian merchant-partners.&nbsp;</div><div><br></div>","id":"989a85d6-22b2-4e17-8298-945e97247331","lists":[{"text":"What You Will Do","content":"<li>Promote sound engineering practices, and drive technical strategy and roadmaps, especially in the frontend area</li><li>Communicate and collaborate effectively with key stakeholders and collaborators among the Engineering Payments team in a global environment, including other engineers, and product managers to identify and solve challenging problems, creating amazing engineering experience for our internal product engineering teams.</li><li>Mentor and provide advice to more junior engineers, guiding them in making sound architectural decisions, improving their code quality, and helping them out of their comfort zone</li><li>Mitigate reliability failures and production issues in our systems</li><li>Bring in-depth knowledge of frontend area to the team and enhance the engineering quality</li><li>Build and operate infrastructure, toolset, and deployment pipeline required to run frontend services</li><li>Continuously improve code quality, product execution, and customer delight</li><li>Be flexible to contribute in the backend area of the platform if necessary and collaborate with the security team to improve the security of our platform</li>"},{"text":"What You Will Need","content":"<li>At least 4+ years of hands-on experience in designing, developing, testing, deploying, and managing large-scale applications based on React, TypeScript, and large data sets</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Solid understanding of building distributed and scalable systems and enjoy seeing everyone in the organization using your applications daily</li><li>Good understanding of data structures and algorithms</li><li>Experience in building developer-facing applications is a plus point</li><li>Exposure to infrastructure tools, including Docker and Kubernetes is a plus point</li>"}],"text":"Senior Frontend Engineer - Online Merchant","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoTo Financial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer for the Commerce Enablement group, you’ll be part of the team building some of the most critical products for GoTo Financial merchant-partners. Working alongside some of the brightest minds in the industry across design, product, and engineering, you’ll focus your efforts on designing and implementing products for a massive network of small, medium and large businesses, improving overall application performance, code structure, and developing robust, well-designed software systems. Your ownership, drive, and passion will help provide for a world-class user experience and heightened stability of our Midtrans products, and directly augment the growth of millions of Southeast Asian merchant-partners.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nAt GoTo Financial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer for the Commerce Enablement group, you’ll be part of the team building some of the most critical products for GoTo Financial merchant-partners. Working alongside some of the brightest minds in the industry across design, product, and engineering, you’ll focus your efforts on designing and implementing products for a massive network of small, medium and large businesses, improving overall application performance, code structure, and developing robust, well-designed software systems. Your ownership, drive, and passion will help provide for a world-class user experience and heightened stability of our Midtrans products, and directly augment the growth of millions of Southeast Asian merchant-partners. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/989a85d6-22b2-4e17-8298-945e97247331","applyUrl":"https://jobs.lever.co/GoToGroup/989a85d6-22b2-4e17-8298-945e97247331/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1706508052225,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","id":"da8d4a37-f5a4-4436-8743-58c787781285","lists":[{"text":"What You Will Do","content":"<li>Take ownership of one of OKR related to demand and growth that leads to revenue and profitability from one of Gojek product’ business; defines the strategy and roadmap for the team to achieve it by combining multiple initiatives (e.g., content/communication, vouchers/promotion, product changes)</li><li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Build predictive model or clustering model to allocate the promo allocation efficiently</li><li>Run multiple experiments to validate hypothesis in fast pace iteration cycle</li><li>Drives the team for prioritization, strategy, and focus on solutions to solve user problems</li><li>Introduce beneficial business changes through well-written strategy documents and validate the strategy and hypotheses through robust experimentation and statistical approach</li><li>Optimize and automate solutions by leveraging Data Sciences resources</li><li>Perform feedback loop and retroactive analysis of the team performance and operation to evaluate and improve their impact on Gojek’'s North Star Metrics</li><li>Proactively review the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Present findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis.</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 5 years of working experience with a minimum of 1-2 year of leadership experience</li><li>Proficiency in data analysis tools and programming languages such as Python, R, SQL, and data visualization tools like Tableau or Power BI. Strong analytical skills to interpret complex data sets and extract actionable insights</li><li>High proficiency in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficiency in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Understanding of business operations, strategies, and objectives. The Consumer Analytics Lead should be able to connect analytical insights to business goals and contribute to overall decision-making</li><li>Data Management: Familiarity with data collection, storage, and management best practices</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Experience in a SaaS, Marketplace, Food Delivery, or other technology company is a plus</li>"}],"text":"Senior Growth Manager - Food & Ads","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285","applyUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1713853876174,"descriptionPlain":"As a Senior Principal Data Scientist, you will be responsible to work across multiple DS teams and influence the technical roadmap to drive best possible solutions to the problem statement. This role will require a combination of a strong data science background and a passion for innovation.\n","description":"<div><span style=\"font-size: 11pt\">As a Senior Principal Data Scientist, you will be responsible to work across multiple DS teams and influence the technical roadmap to drive best possible solutions to the problem statement. This role will require a combination of a strong data science background and a passion for innovation.</span></div>","id":"c54483cb-dd68-43c3-9fe5-623dbb6db56f","lists":[{"text":"What you will do","content":"<li>Design large-scale AI/ML products/systems impacting millions of customers</li><li>Establish best practices for data science methodologies, tools, and technologies to ensure high-quality deliverables and efficient workflows.</li><li>Mentored and coach junior data scientists, providing guidance on technical skills, project management, and career development.</li><li>Led the design, development, and execution of Proof of Concepts (POCs) using emerging data technologies to solve complex business problems.</li><li>Drive and ensure that MLOps practices are being followed in solutions</li><li>Collaborate with cross-functional teams across data and engineering to come up with solutions to complex problem statements.</li><li>Stay current on industry trends and advancements in data science, machine learning, and artificial intelligence, and assess their potential impact on our projects and processes.</li><li>Contribute to thought leadership initiatives such as white papers, conference presentations, and blog posts to showcase our expertise and drive industry recognition.</li><li>Act as a subject matter expert on data science topics, providing guidance and support to internal teams.</li>"},{"text":"What You Will Need","content":"<li>Advanced degree (Master’s or PhD) in Data science.</li><li>Proven track record of success in a data science role, with at least 12 years of experience in applied machine learning, predictive modeling, and data analysis.</li><li>Expertise in programming languages such as Python, R, or Scala, as well as proficiency with data manipulation and visualization libraries (e.g., pandas, NumPy, matplotlib, seaborn).</li><li>Strong understanding of statistical concepts and techniques, with experience applying them to real-world problems.</li><li>Experience with big data technologies such as Hadoop, Spark, or Flink, and proficiency in SQL and/or NoSQL databases.</li><li>Excellent communication and interpersonal skills, with the ability to effectively convey complex technical concepts to both technical and non-technical audiences.</li><li>Leadership experience, including the ability to mentor and coach junior team members and drive cross-functional collaboration.</li><li>A passion for learning and innovation, with a desire to stay ahead of the curve in the rapidly evolving field of data science and technology.</li>"},{"text":"Plus Point","content":"<li>Experience with ride-hailing, quick commerce or food delivery domain.</li><li>Experience working with unstructured or semi-structured data and human-in-the-loop data operations.</li><li>Experience with distributed systems</li>"},{"text":"About the team","content":"<li>Our Data Science team currently consists of 40+ people based in India, Indonesia and Singapore who run Southeast Asia’s leading Gojek business. We oversee all things data and work to become a thought partner for our Business Users, Product Team, and Decision Makers. It’s our job to ensure that they have a structural approach to data-driven problem-solving. Right now, our focus revolves: how to make customers, drivers, and merchants happy and delighted. We have so far created millions of dollar impact across different journeys of customers, drivers and merchants</li><div><br></div><li>We work with the Engineering, PMs and strategy functions hand-in-glove - be it constructing a new product or brainstorming on a problem like how do we reduce the wait time for the drive, how do we improve assortment, should we treat convenience seeking customer differently from value seeking customer etc</li><div><br></div><li>As a team, we’re concerned not only with the growth of the company, but each other’s personal and professional growths, too. Along with us coming from diverse backgrounds, we often have fun sessions to talk about everything and anything from data information to our current movie list.</li>"}],"text":"Senior Principal Data Scientist","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 11pt;\">As a Senior Principal Data Scientist, you will be responsible to work across multiple DS teams and influence the technical roadmap to drive best possible solutions to the problem statement. This role will require a combination of a strong data science background and a passion for innovation.</span></div>","descriptionBodyPlain":"As a Senior Principal Data Scientist, you will be responsible to work across multiple DS teams and influence the technical roadmap to drive best possible solutions to the problem statement. This role will require a combination of a strong data science background and a passion for innovation.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c54483cb-dd68-43c3-9fe5-623dbb6db56f","applyUrl":"https://jobs.lever.co/GoToGroup/c54483cb-dd68-43c3-9fe5-623dbb6db56f/apply"},{"additionalPlain":"About The Team\n\nOur Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. </div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1717126992883,"descriptionPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","id":"50c8a826-2076-40a3-a829-b96b29c9647f","lists":[{"text":"What You Will Do","content":"<li>Conduct research to understand merchants needs and behavior and analyze product performance data to identify opportunities&nbsp;</li><li>Developing and executing a data-driven marketing strategy that aligns with the overall business objectives</li><li>Create product positioning and messaging to differentiate our products from competitors</li><li>Creating and managing marketing campaigns across various channels, including search, social media, and email marketing by working together with both internal and external stakeholders to deliver the plan</li><li>Developing and managing referral or other marketing programs to drive merchant acquisition</li><li>Identify, develop, implement, and refine consumer-focused lifecycle &amp; retention marketing strategies</li><li>Continuously monitor and analyze data to create campaign or marketing reports</li><li>Running A/B tests and analyzing results to optimize conversion rates and user acquisition.</li>"},{"text":"What You Will Need","content":"<li>3+ years working experience in Tech, Bank, Consulting or Marketing Agencies</li><li>2+ years experience in marketing or growth roles</li><li>Customer obsession and passionate in marketing</li><li>Strong analytical skills, data-driven and delighted with statistical analysis and figures</li><li>Strong communication skills, collaborative spirit, delighted to work with other stakeholders (BI/Data, Business, Product, Leadership)</li><li>Strong business sense and problem-solving skills</li>"}],"text":"Senior Product Marketing Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f","applyUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f/apply"},{"additionalPlain":"About the Team \n\nFood Pod Research Team consists of a tight-knit group made up of researchers with different backgrounds and interests. Currently, our team has been busy working on elevating the Food Business to the next level in Indonesia and Vietnam. We welcome those who are passionate about exploring trending food with us in Blok M or trying out different sports activities (squash, tennis, yoga, pilates, swimming, running, dancing, muay Thai, softball, what’s next?)\n\n\n","additional":"<div>About the Team </div><div><br></div><div>Food Pod Research Team consists of a tight-knit group made up of researchers with different backgrounds and interests. Currently, our team has been busy working on elevating the Food Business to the next level in Indonesia and Vietnam. We welcome those who are passionate about exploring trending food with us in Blok M or trying out different sports activities (squash, tennis, yoga, pilates, swimming, running, dancing, muay Thai, softball, what’s next?)</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718796328782,"descriptionPlain":"About the Role \n\nThey say no man is an island, and this notion holds particularly true for this role. As our researcher, you’ll be an instrumental cog in the Food Pod Research at Gojek (Online Food Delivery, Groceries, Ads Business) that directly impacts the company’s direction and decision on strategies, product to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to answer company objectives. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Best yet, you’ll have the opportunity to flex your quantitative & qualitative research skills, as well as dig deeper with big data.. getting us even closer as a thinking partner and navigator for our stakeholders.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our researcher, you’ll be an instrumental cog in the Food Pod Research at Gojek (Online Food Delivery, Groceries, Ads Business) that directly impacts the company’s direction and decision on strategies, product to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to answer company objectives. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Best yet, you’ll have the opportunity to flex your quantitative &amp; qualitative research skills, as well as dig deeper with big data.. getting us even closer as a thinking partner and navigator for our stakeholders.</div><div><br></div><div><br></div>","id":"12b79ada-f0fb-456f-9aa9-0745f9aa12d2","lists":[{"text":"What You Will Do","content":"<li>Execute and manage research works for Food ecosystems (customers, merchants, and drivers), including defining tasks involved in a workload&nbsp; with minimum supervision from seniors and/or lead&nbsp;</li><li>Initiate and manage relationships with stakeholders (Product, Design, Strategic &amp; Planning, &amp; Marketing team), including involved in scoping research works and roadmaps for the stream with minimum supervision</li><li>Conduct and lead synthesizing, report writing, and workshop facilitation processes to come up with actionable insights for product &amp; business development, such as product concept testing, usability testing, post-launch evaluation study, brand health tracking, pricing study, etc</li><li>Implement a holistic approach to data analysis: combining and triangulating different sources and disciplines</li><li>Demonstrate comprehension of business acumen (e.g. consumer dynamics, business, economics, culture)&nbsp; to recognize the broader issues that contribute to existing research questions and strategic decision</li><li>Create and implement strategic prioritization into their day-to-day work</li><li>Influence strategic decision-making of their stakeholders through insights sharing formally and informally&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Minimum 5 years of consumer/market research experience. Prior exposure to working in a top-tier market research agency/consultant firm&nbsp; and/or Product research projects is a plus</li><li>Proficiency in both quantitative &amp; qualitative research methods, and a good understanding of the Indonesian market and culture</li><li>Vast exposure to different research questions and methodology, especially related to strategic focus (Usage &amp; Attitude, Brand Health Tracking, segmentation, pricing study, etc.)</li><li>Experience in research for tech industries or market segments relevant to our organization is desirable</li><li>Strong analytical thinking skills and the aptitude to pick up new skills quickly</li><li>Excellent communication and language skills in Bahasa and English (writing &amp; speaking)</li><li>Proven effective project management skills, communication skills, and strategic thinking capability with an orientation to detail</li><li>Confident and comfortable facing, influencing, and getting buy-in from internal &amp; external stakeholders in day-to-day activities</li><li>A desire to work in a fast-paced environment with a dedicated commitment. A self-motivator for learning, problem-solving, and deep-diving into complex concepts</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior Researcher - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our researcher, you’ll be an instrumental cog in the Food Pod Research at Gojek (Online Food Delivery, Groceries, Ads Business) that directly impacts the company’s direction and decision on strategies, product to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to answer company objectives. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Best yet, you’ll have the opportunity to flex your quantitative &amp; qualitative research skills, as well as dig deeper with big data.. getting us even closer as a thinking partner and navigator for our stakeholders.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nThey say no man is an island, and this notion holds particularly true for this role. As our researcher, you’ll be an instrumental cog in the Food Pod Research at Gojek (Online Food Delivery, Groceries, Ads Business) that directly impacts the company’s direction and decision on strategies, product to build, and what to do to grow our business. Your main objectives will be to plan and execute research projects and present them to answer company objectives. Your manager will work with you to develop your skills and knowledge and to ensure the quality of the research. Best yet, you’ll have the opportunity to flex your quantitative & qualitative research skills, as well as dig deeper with big data.. getting us even closer as a thinking partner and navigator for our stakeholders.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/12b79ada-f0fb-456f-9aa9-0745f9aa12d2","applyUrl":"https://jobs.lever.co/GoToGroup/12b79ada-f0fb-456f-9aa9-0745f9aa12d2/apply"},{"additionalPlain":"About The Team\n\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707805477238,"descriptionPlain":"About The Role\n\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","id":"60b17958-bbef-411b-9024-5cbbabf12fff","lists":[{"text":"What You Will Do","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed</li><li>Resolve account issues and complaints</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms</li>"},{"text":"What This Role Needs","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area</li><li>At least 6 years of experience in business management, sales, or project management is mandatory. Prior experience in e-commerce and managing key accounts will be a plus point</li><li>Fluency in both Bahasa and English is required</li><li>Able to multitask, prioritize, and manage time efficiently</li><li>Ability to negotiate, persuade and influence others</li><li>Excellent interpersonal, communication, presentation and analytical skills</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners</li>"}],"text":"Senior Sales Manager - Midtrans - #9679","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","descriptionBodyPlain":"About The Role\n\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/60b17958-bbef-411b-9024-5cbbabf12fff","applyUrl":"https://jobs.lever.co/GoToGroup/60b17958-bbef-411b-9024-5cbbabf12fff/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1706837996316,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"93b5e2e0-272f-4091-b7aa-fafc06ca67c4","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>4-6+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"Senior SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4","applyUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"Fintech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1713798737839,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"a4510adc-edf8-4bb4-bf25-3315f61f112d","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Merchant Gateway","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a4510adc-edf8-4bb4-bf25-3315f61f112d","applyUrl":"https://jobs.lever.co/GoToGroup/a4510adc-edf8-4bb4-bf25-3315f61f112d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"Fintech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1718166252841,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"e8141985-a154-462d-b218-e386f9d27364","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Mobile Application (Gojek & Gopay)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e8141985-a154-462d-b218-e386f9d27364","applyUrl":"https://jobs.lever.co/GoToGroup/e8141985-a154-462d-b218-e386f9d27364/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"Fintech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1713506558950,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"076bd021-0157-42a4-89fd-51d9f236e490","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Payment Widget & Vendor Gateway","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490","applyUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711358848361,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"68f907a3-329f-411b-af2d-a66b38243919","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 5 years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>You have working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>You have Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, XGBoost, Keras</li>"}],"text":"Senior Software Engineer - Data Science Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919","applyUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1711536111124,"descriptionPlain":"About the Role\n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","id":"0216fdb3-64c6-4e37-ace8-1d9c0c79ca23","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems</li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure</li><li>Enhance code quality and product performance through continuous improvement and innovation</li><li>Collaborate and communicate effectively with teams across multiple geographies</li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves</li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Atleast 4-5+ years of relevant experience in building applications from scratch, with proficiency in an object oriented or functional programming language (e.g. Java, Golang, Clojure, Python, Ruby etc)</li><li>Solid understanding of distributed systems fundamentals and the ability to troubleshoot issues in a large-scale infrastructure.</li><li>Hands-on experience with container orchestration and cloud native infrastructure technologies such as Kubernetes and Docker</li><li>Strong domain modeling skills and the ability to build RESTFul web services</li><li>Familiarity with CI/CD pipelines and Infrastructure as Code tools, including Terraform and Helm.</li><li>Deep knowledge or Linux as a production environment</li><li>Working knowledge of the TCP/IP stack, internet routing and load balancing</li><li>Prior experience with cloud platforms (e.g. AWS, GCP, Azure) is a plus</li><div><br></div>"}],"text":"Senior Software Engineer - Event Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0216fdb3-64c6-4e37-ace8-1d9c0c79ca23","applyUrl":"https://jobs.lever.co/GoToGroup/0216fdb3-64c6-4e37-ace8-1d9c0c79ca23/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718187134939,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"53c0b8a9-1a83-4c34-9a59-b5170ce54193","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Senior Software Engineer - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193","applyUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193/apply"},{"additionalPlain":"About the team \n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the team </b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713777541586,"descriptionPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","description":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","id":"ad7a1160-4d07-4f4a-a2d3-c362afac18ac","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis and MySQL</li><li>Contribute to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred</li><li>Familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis</li><li>Familiar with Linux operating systems, understand database principles, and proficient in using databases like MySQL and Oracle</li><li>Good coding style and code specifications, and be able to independently complete project development</li><li>Good communication skills and teamwork spirit, and be able to collaborate effectively with other developers</li><li>knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Backend) - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","descriptionBodyPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac","applyUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710229562529,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"10dbc666-80f8-4250-85ee-59fa92d056aa","lists":[{"text":"What You Will Do","content":"<li>Build and maintain data products for the data engineering platform for the data infrastructure and streaming services.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of microservices on Kubernetes</li><li>Design and deploy the data products on the Google Cloud Platform</li><li>Collaborate with the data team and business teams to understand their requirements</li><li>Auto-scaling and monitoring performance of the streaming Infrastructure and applications by using Prometheus and Grafana or similar tools</li>"},{"text":"What You Will Need","content":"<li>A minimum of 3-6 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Experience in building real time streaming applications using Flink/Java OR building data platform products using Golang.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Good understanding of messaging queues like kafka and NoSQL databases.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Data Platform) - Payments Data Products & Infra","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa","applyUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa/apply"},{"additionalPlain":"About the Team\n\nConsumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714016329286,"descriptionPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","id":"88358de8-e37b-4bd6-9afe-359eea3128b9","lists":[{"text":"What You Will Do","content":"<li>Own feature development from end-to-end, constantly pair with junior engineers, and improve them.</li><li>Write code that's clear, concise, performant, tested, and easy to understand by other teams and engineers.</li><li>Contribute to the design and development of highly scalable, available, reliable, secure, and fault-tolerant services.</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices.</li><li>Deep dive and debug production issues across services and levels of the stack when needed.</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently.</li>"},{"text":"What You Will Need","content":"<li>Passion for software development</li><li>At least 4 years of relevant software development experience with consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Ability to learn or use Java, Kotlin, and JS, proficiency in at least one of them</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, database consistency and transactionality, asynchronous programming, fault tolerance and monitoring, performance, feature flags, and backward compatibility&nbsp;</li><li>Understanding of a mobile application’s interaction with the back-end and other systems</li><li>Deep understanding of relational databases; ability to design performant, easy-to-understand architectures, and know-how for applying changes with no downtime to production systems</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, AWS, GCP</li>"}],"text":"Senior Software Engineer (Full Stack) - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","descriptionBodyPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9","applyUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1716821917651,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"8afd4278-a5a8-43f2-8718-2986433f2ddb","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.&nbsp;&nbsp;</li>"}],"text":"Senior Technical Program Manager - Engineering Platform (Bangalore)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb","applyUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb/apply"},{"additionalPlain":"About The Team\n\nWe are dedicated to fostering a vibrant culture and value work life balance. Our team thrives on dynamism, comprising individuals who are not only interesting but also exceptionally empathetic. At the heart of our ethos lies a deep appreciation for every aspect of your contribution - not just the tasks you will undertake, but also the unique qualities that make you who you are.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>We are dedicated to fostering a vibrant culture and value work life balance. Our team thrives on dynamism, comprising individuals who are not only interesting but also exceptionally empathetic. At the heart of our ethos lies a deep appreciation for every aspect of your contribution - not just the tasks you will undertake, but also the unique qualities that make you who you are.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711090944722,"descriptionPlain":"About The Role\n\nWe are seeking a highly skilled and motivated Transfer Pricing Senior Associate to join our team. As a Transfer Pricing Senior Associate, you will work directly with the Transfer Pricing Manager and Transfer Pricing Lead, playing a crucial role in shaping our organization's transfer pricing function.You will be part of a vibrant team who delivers highly tax-efficient transfer pricing planning solutions and ideas. Responsibilities include providing advice to simplify and structure global and cross-border operations to meet local best practices, preparing transfer pricing documentation, ensuring TP operational excellence and TP audit defense.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a highly skilled and motivated Transfer Pricing Senior Associate to join our team. As a Transfer Pricing Senior Associate, you will work directly with the Transfer Pricing Manager and Transfer Pricing Lead, playing a crucial role in shaping our organization's transfer pricing function.You will be part of a vibrant team who delivers highly tax-efficient transfer pricing planning solutions and ideas. Responsibilities include providing advice to simplify and structure global and cross-border operations to meet local best practices, preparing transfer pricing documentation, ensuring TP operational excellence and TP audit defense.</div>","id":"a209e959-6eaf-4d0e-807a-42dcaffbaf91","lists":[{"text":"What you will do","content":"<li>Collaborate with the Transfer Pricing Manager and Head of Transfer Pricing on external and internal transfer pricing documentation.</li><li>Gain a deep understanding of the company's operations, including cost centers and basic operational processes.</li><li>Assist in the development and implementation of transfer pricing strategies to ensure compliance with local and international regulations.</li><li>Conduct thorough analysis and research to support transfer pricing recommendations.</li><li>Communicate effectively with cross-functional teams to gather necessary information and data for transfer pricing documentation.</li><li>Work independently while also contributing effectively to team projects and initiatives.</li>"},{"text":"What you will need","content":"<li>At least 2 years of transfer pricing experience preferably with a corporation or international accounting firm.</li><li>Bachelor's degree in Accounting, Finance, or related field. Advanced degree or professional certification (e.g., Brevet) is a plus.</li><li>Knowledge in CIT, VAT, and WHT is a plus.</li><li>Solid understanding of transfer pricing principles and methodologies.</li><li>Proficiency in English is essential, with excellent communication skills both written and verbal.</li><li>Ability to work effectively in a fast-paced environment and manage multiple priorities.</li><li>Strong analytical skills and attention to detail.</li><li>A proactive mindset with the ability to work both independently and collaboratively within a team.</li>"}],"text":"Senior Transfer Pricing","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a highly skilled and motivated Transfer Pricing Senior Associate to join our team. As a Transfer Pricing Senior Associate, you will work directly with the Transfer Pricing Manager and Transfer Pricing Lead, playing a crucial role in shaping our organization's transfer pricing function.You will be part of a vibrant team who delivers highly tax-efficient transfer pricing planning solutions and ideas. Responsibilities include providing advice to simplify and structure global and cross-border operations to meet local best practices, preparing transfer pricing documentation, ensuring TP operational excellence and TP audit defense.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a highly skilled and motivated Transfer Pricing Senior Associate to join our team. As a Transfer Pricing Senior Associate, you will work directly with the Transfer Pricing Manager and Transfer Pricing Lead, playing a crucial role in shaping our organization's transfer pricing function.You will be part of a vibrant team who delivers highly tax-efficient transfer pricing planning solutions and ideas. Responsibilities include providing advice to simplify and structure global and cross-border operations to meet local best practices, preparing transfer pricing documentation, ensuring TP operational excellence and TP audit defense.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a209e959-6eaf-4d0e-807a-42dcaffbaf91","applyUrl":"https://jobs.lever.co/GoToGroup/a209e959-6eaf-4d0e-807a-42dcaffbaf91/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717153383212,"descriptionPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","description":"<div><span style=\"font-size: 9pt\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","id":"3377f50a-d56f-42e0-acc5-b69d405a37a9","lists":[{"text":"What You Will Do","content":"<li>Identify and pursue strategic partnership opportunities that align with company goals - B2B in financial and non financial sectors</li><li>Negotiate terms and agreements with partners to drive mutual commercial successDevelop and maintain strong relationships with external partners to foster long-term collaboration</li><li>Collaborate with partners to create joint business plans aimed at achieving quarterly (QoQ) and yearly (YoY) growth targets</li><li>Monitor and analyze partnership performance, providing insights and recommendations for improvement</li><li>Work closely with internal teams, including sales, marketing, product, and finance, to ensure partnership initiatives are aligned with company objectives and obtain their successful buy in to projects and programs</li><li>Facilitate effective communication and collaboration across departments to gain buy-in for partnership strategies</li><li>Act as a liaison between partners and internal stakeholders to address any issues and optimize partnership outcomes</li><li>Be the first hand to handle issues related to the partnership and escalate the issue to the right parties (internal and external) to be solved</li><div><br></div>"},{"text":"What You Will Need ","content":"<li>Minimum Bachelor’s degree</li><li>Minimum 5 years of professional experience in partnership development or business development in companies such as start-ups, technology companies, management consulting, banking, or Fortune 500 companies</li><li>Data Analysis: Strong ability to crunch data and perform detailed data analysis. This includes interpreting complex datasets to derive actionable insights and support decision-making.</li><li>P&amp;L Understanding: Good understanding of Profit and Loss statements, with the ability to analyze financial performance and identify <a href=\"http://trends.Business\" class=\"postings-link\">trends.</a></li><li><a href=\"http://trends.Business\" class=\"postings-link\">Business</a> Acumen: Solid business acumen, enabling the development, management, and execution of business agreements and contracts. This involves a deep comprehension of business operations and strategic <a href=\"http://planning.Critical\" class=\"postings-link\">planning.</a></li><li><a href=\"http://planning.Critical\" class=\"postings-link\">Critical</a> Thinking and Problem Solving: Draws sound conclusions based upon a mixture of analysis and experience. Able to identify breakthrough solutions during tough negotiations or large-scale implementations with strategic <a href=\"http://partners.Communications\" class=\"postings-link\">partners.</a></li><li><a href=\"http://partners.Communications\" class=\"postings-link\">Communications</a> Skills: Promotes an environment of open communication. Convinces and engages others by using compelling arguments. Able to rigorously manage a portfolio of projects with strategic partners, unblock issues &amp; risks and manage expectations to ensure they are completed within target timelines and stakeholder <a href=\"http://expectations.Stakeholder\" class=\"postings-link\">expectations.</a></li><li><a href=\"http://expectations.Stakeholder\" class=\"postings-link\">Stakeholder</a> Management: Ability to develop strong, long lasting relationships with both internal and external stakeholders at all levels. Persuades and influences effectively by building support for ideas and initiatives through the effective presentation of facts and evidence. Identifies and anticipates that the partner and stakeholder needs to gain their commitment. Owns the end-to-end relationship with equivalent team and functional leads both internally and <a href=\"http://externally.B2B\" class=\"postings-link\">externally.</a></li><li><a href=\"http://externally.B2B\" class=\"postings-link\">B2B</a> Negotiation Skills: A fair, unbiased mediator and uses diplomacy and tact to diffuse tense situations comfortably</li><li>Resiliency : Demonstrates resilience &amp; composure, even in difficult or adverse circumstances. Makes and carries through unpopular or difficult decisions that are in the best interest of the team. Is able to resist the pressure to make quick decisions where due consideration is <a href=\"http://required.Abilities\" class=\"postings-link\">required.</a></li><li><a href=\"http://required.Abilities\" class=\"postings-link\">Abilities</a> to navigate and execute in a highly ambiguous environmentLocal candidates is a must</li><div><br></div>"}],"text":"Senior/Partnership Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt;\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","descriptionBodyPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","hostedUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9","applyUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9/apply"},{"additionalPlain":"About the Team\n\nAs a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.\n\nOur team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>As a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.</div><div><br></div><div>Our team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705293453270,"descriptionPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","id":"9b2d9240-3315-4b28-a7d6-73e2a097c8d7","lists":[{"text":"What You Will Do","content":"<li>Proactively monitor and troubleshoot system performance, identifying and addressing potential issues.</li><li>Collaborate with development teams to design and implement scalable and resilient system architectures.</li><li>Develop and maintain automation tools to streamline processes and enhance overall system efficiency.</li><li>Participate in incident response activities, conducting root cause analysis</li><li>Contribute to the ongoing improvement of reliability, scalability, and performance of critical infrastructure.</li><li>Work closely with cross-functional teams to align SRE efforts with broader organizational goals.</li>"},{"text":"What You Will Need","content":"<li>Solid understanding of cloud platforms such as GCP, and expertise in deploying and managing services within these environments.</li><li>In-depth knowledge of containerization technologies like Docker and orchestration tools such as Kubernetes</li><li>Proficiency in programming languages like Python, Go, or Java, with a strong software engineering foundation</li><li>Able to manage small teams and also can work as an individual contributor</li><li>Familiarity with Linux System, monitoring and logging tools to ensure comprehensive system visibility such as Prometheus, Grafana, and ELK stack</li><li>Proven track record of implementing and maintaining automation for deployment, scaling, and system orchestration.</li>"}],"text":"Site Reliability Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","descriptionBodyPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7","applyUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7/apply"},{"additionalPlain":"About the Team \n\nOur Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.\n\nHaving a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.  \n\nWe are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Our Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.</div><div><br></div><div>Having a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.&nbsp;&nbsp;</div><div><br></div><div>We are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717664713208,"descriptionPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","id":"f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","lists":[{"text":"What Will You Do ","content":"<li>Be the person in charge to create social media campaign and content; from observing trends and references, brainstorming, planning to execution (including schedule and post)</li><li>Develop social media campaigns strategies collaborate with other stakeholders&nbsp;&nbsp;</li><li>Create KOL strategy collaborate with stakeholders and third parties</li><li>Utilizing social media tools to analyze social media campaign, content, and KOL to gather insight and action plan</li><li>Collaborate with brand marketing to deliver/support marketing needs</li>"},{"text":"What Will You Need","content":"<li>At least 3-5 years related work experience from an advertising agency or start-up</li><li>Strong writing, editing, and proof-reading skills</li><li>Ability to communicate ideas clearly; a strong analytical, data-driven mindset</li><li>Broad knowledge of social media landscape, platforms, and technologies</li><li>Have interest in digital platforms, particularly in social media, and a willingness to learn more about this digital space</li><li>Strong team player with a proactive attitude and a creative/innovative mind to collaborate with multiple stakeholders</li><li>Strong analytical abilities to read, interpret, and utilize data, and to come up with actionable points for optimization and/or experimentation</li><li>Robust and detail-oriented to handle multiple works</li>"}],"text":"Social Media Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","descriptionBodyPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","applyUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3/apply"},{"additionalPlain":"About the Team\n\nThe Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).\n\nOne of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.\n\nOff hours, you’d probably find us hang out, dinner together or playing games\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).</div><div><br></div><div>One of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.</div><div><br></div><div>Off hours, you’d probably find us hang out, dinner together or playing games</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697610584742,"descriptionPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","id":"cd554abc-dc06-4177-be50-ccbc638fd6d9","lists":[{"text":"What You Will Do","content":"<li>Work closely with team lead to deliver product features that enable efficient handling of queries for our internal users (customer service agents) and complaints raised by external users (customer, driver, and merchant)</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems</li><li>Write code that’s clear, concise, performant, tested and easily understood by others</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Writing technical documents and providing technical training for end users if necessary</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2-3+ years of hands-on experience in designing, developing, testing, and deploying applications on Go-Lang, Clojure, Java, Ruby, or OOPL large-scale applications</li><li>In-depth experience&nbsp;of at least one programming language and framework, deep understanding of SQL databases, Linux, Kafka, Redis, and RabbitMQ</li><li>Proficient in OOP, SQL, Design Patterns Data modeling experience in Relational databases</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate risks</li>"}],"text":"Software Engineer - Customer Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9","applyUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716357496028,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"3c6bca98-cc50-43be-bafd-46ea1ab35594","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 2-3+ years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink is a plus</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>You have working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>You have Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, XGBoost, Keras</li>"}],"text":"Software Engineer - Data Science Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3c6bca98-cc50-43be-bafd-46ea1ab35594","applyUrl":"https://jobs.lever.co/GoToGroup/3c6bca98-cc50-43be-bafd-46ea1ab35594/apply"},{"additionalPlain":"About the Team :\nWe are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \nThis includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team :</b></div><div><span style=\"font-size: 10pt\">We are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><span style=\"font-size: 10pt\">This includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><span style=\"font-size: 10pt\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718186798651,"descriptionPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","id":"6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","lists":[{"text":"What You Will Do","content":"<li>Build highly reliable frontend apps through appealing visual design with API integrations to support continuing increases in adoption of the products within Gojek</li><li>Work with engineers to understand the nature and background of the problems.</li><li>Work closely with all Data Platform teams to develop and rollout high quality products</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Contribute to improving team relatedness, and helps build a culture of camaraderie</li><li>Continuously refactor applications to ensure high-quality</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript.</li><li>Solid command over React JS with the flavor of TypeScript.</li><li>Keen design and UX sense to analyze and understand the designs and wireframes.</li><li>Good understanding of common web security threats and practices along with OWASP 10.</li><li>Experience with <a href=\"http://node.js\" class=\"postings-link\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server.</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management.</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Software Engineer - Engineering Platforms","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt;\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt;\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","descriptionBodyPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","applyUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e/apply"},{"additionalPlain":"About the Team\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716980506841,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","id":"930cfb6b-99e3-4334-bc10-3fac18f8eff0","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Helping out in onboarding process by sharing contexts and pairing with new member of the team</li><li>Start mentoring or guiding SE1</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years relevant software development experience through internship stint and/or college projects</li><li>Proficient in Kotlin programming, Java and the Android APIs. </li><li>Strong knowledge in Android Apps architecture and implementationAbility to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular libraries for networking, async, image loading etc.</li><li>Well-versed with Agile methodologies, TDD and Test Engineering and Automation.</li>"}],"text":"Software Engineer (Android) - Gofood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0","applyUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713521223842,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"331177df-4294-4bc1-93a4-6459ff18ef97","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97","applyUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97/apply"},{"additionalPlain":"About the team\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n","additional":"<div><b style=\"font-size: 16px\">About the team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716979903445,"descriptionPlain":"About the role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the iOS Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","description":"<div><b style=\"font-size: 16px\">About the role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the iOS Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","id":"16a62a49-46a3-4683-b1b1-e42e60c2c7e8","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Helping out in onboarding process by sharing contexts and pairing with new member of the team</li><li>Start mentoring or guiding SE1</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years relevant software development experience through internship stint and/or college projects</li><li>Proficient in Swift programming, Cocoa Touch, Xcode and the iOS SDK.</li><li>Understanding of iOS Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular libraries for networking, async, image loading etc.</li>"}],"text":"Software Engineer (iOS) - Gofood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the iOS Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","descriptionBodyPlain":"About the role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the iOS Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/16a62a49-46a3-4683-b1b1-e42e60c2c7e8","applyUrl":"https://jobs.lever.co/GoToGroup/16a62a49-46a3-4683-b1b1-e42e60c2c7e8/apply"},{"additionalPlain":"About the Team\n\nGojek’s Groceries vertical - GoMart, launched amid Covid to deliver fresh and packaged daily staples to our users through an on demand, instant delivery experience. The groceries product group is working to build the leading online grocery ecosystem in Indonesia. GoMart, the B2C online grocery service, has grown to be the leader in delivering convenience items to our consumers in major cities across Indonesia. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit work with us and let's solve the problems with technology.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Groceries vertical - GoMart, launched amid Covid to deliver fresh and packaged daily staples to our users through an on demand, instant delivery experience. The groceries product group is working to build the leading online grocery ecosystem in Indonesia. GoMart, the B2C online grocery service, has grown to be the leader in delivering convenience items to our consumers in major cities across Indonesia. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit work with us and let's solve the problems with technology.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1713518609186,"descriptionPlain":"About the Role\n\nAre you interested in solving deep user experience problems? Are you looking to build features which will be used by millions of customers everyday? Do you want to work with an amazing team? Then, this may be the role for you. As a member of the Groceries team, you will be building the best user experience for Gojek's users for iOS App. You would primarily focus on Gomart screen redesign, development, performance, analytics Metrics.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Are you interested in solving deep user experience problems? Are you looking to build features which will be used by millions of customers everyday? Do you want to work with an amazing team? Then, this may be the role for you. As a member of the Groceries team, you will be building the best user experience for Gojek's users for iOS App. You would primarily focus on Gomart screen redesign, development, performance, analytics Metrics.</span></div>","id":"9fa9af02-5e5c-4812-b98f-fba1a5041b25","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>1-2+ years of experience with iOS development</li><li>In-depth knowledge of iOS Apps architecture (MVVM/VIPER) and implementation including proficiency in Swift programming, Cocoa, Xcode and the iOS SDK</li><li>A Bachelor’s/Master’s degree in Computer Science</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Good to have experience with popular libraries for networking, async, image loading etc</li>"}],"text":"Software Engineer (iOS) - Groceries","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Are you interested in solving deep user experience problems? Are you looking to build features which will be used by millions of customers everyday? Do you want to work with an amazing team? Then, this may be the role for you. As a member of the Groceries team, you will be building the best user experience for Gojek's users for iOS App. You would primarily focus on Gomart screen redesign, development, performance, analytics Metrics.</span></div>","descriptionBodyPlain":"About the Role\n\nAre you interested in solving deep user experience problems? Are you looking to build features which will be used by millions of customers everyday? Do you want to work with an amazing team? Then, this may be the role for you. As a member of the Groceries team, you will be building the best user experience for Gojek's users for iOS App. You would primarily focus on Gomart screen redesign, development, performance, analytics Metrics.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9fa9af02-5e5c-4812-b98f-fba1a5041b25","applyUrl":"https://jobs.lever.co/GoToGroup/9fa9af02-5e5c-4812-b98f-fba1a5041b25/apply"},{"additionalPlain":" About the team\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div>&nbsp;<span style=\"font-size: 16px\">About the team</span></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717646754658,"descriptionPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","id":"a161ba72-275d-4225-85c0-fac7f782b397","lists":[{"text":"What You Will Do","content":"<li>Solve technical problems and build the next generation of products for our consumers</li><li>Spike new technologies and find a viable way to improve customers experience</li><li>Improve the testability and maintainability of the code</li><li>Build reusable iOS software components for interfacing with multiple applications</li><li>Improve and stabilize IOS sdks used by number of internal and external clients</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>At Least 2 years of full-time iOS engineering experience</li><li>Experience developing, maintaining, and innovating large scale, consumer mobile application</li><li>Predictability and balance of product delivery speed and quality</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in <b>Swift programming</b>, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Working experience with popular libraries for networking, async, image loading, etc</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><li>Experience and knowledge of writing testable and high-quality code</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (iOS) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","descriptionBodyPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/a161ba72-275d-4225-85c0-fac7f782b397","applyUrl":"https://jobs.lever.co/GoToGroup/a161ba72-275d-4225-85c0-fac7f782b397/apply"},{"additionalPlain":"About the team \n\nGoFood Merchant Growth Marketing is part of the GoFood Business & Ads team, based in Jakarta. We trust in data, magic, and a supportive attitude to work with. We need strong team players to help us grow our merchant further as part of our stakeholders, to achieve both business & brand goals. In summary, we will allow you to have a bird’s eye view of how campaigns, both online and offline, are impacting conversions and the broader customer experience! “Seeing is Believing\" is our soul to make a joyful experience for all foodies. We are a group made up of food enthusiasts (absolutely!), funny thinkers, great eaters, and people who are ready to stay up late for big events lol. We also value every opinion and idea.  \n\n","additional":"<div><b>About the team </b></div><div><br></div><div>GoFood Merchant Growth Marketing is part of the GoFood Business &amp; Ads team, based in Jakarta. We trust in data, magic, and a supportive attitude to work with. We need strong team players to help us grow our merchant further as part of our stakeholders, to achieve both business &amp; brand goals. In summary, we will allow you to have a bird’s eye view of how campaigns, both online and offline, are impacting conversions and the broader customer experience! “Seeing is Believing\" is our soul to make a joyful experience for all foodies. We are a group made up of food enthusiasts (absolutely!), funny thinkers, great eaters, and people who are ready to stay up late for big events lol. We also value every opinion and idea.&nbsp;&nbsp;</div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718092151738,"descriptionPlain":"About the Role\n\nFasten your helmet and climb aboard, if you’re ready to be our Sr. Marketing Executive - Brand Campaign for GoFood. In this role, you will be part of the GoFood Business & Ads team based in Jakarta, Indonesia. Managing campaign strategy and executing go-to-market strategy for our brand thematic and merchant promotional campaigns. This role is crucial in planning & implementing campaign plans such as communication strategy, content development and media placement. The folks in the Sales, Product, Data & Insights, Performance and Creative teams will be your companions.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Fasten your helmet and climb aboard, if you’re ready to be our Sr. Marketing Executive - Brand Campaign for GoFood. In this role, you will be part of the GoFood Business &amp; Ads team based in Jakarta, Indonesia. Managing campaign strategy and executing go-to-market strategy for our brand thematic and merchant promotional campaigns. This role is crucial in planning &amp; implementing campaign plans such as communication strategy, content development and media placement. The folks in the Sales, Product, Data &amp; Insights, Performance and Creative teams will be your companions.</div><div><br></div><div><br></div>","id":"baf1c074-dffd-41d9-ad55-796428e4d1c8","lists":[{"text":"What you will do","content":"<li><b>Collaborate with the Marketing Manager</b> to develop brand thematic &amp; merchant promotional campaigns including campaign briefing, generating insights, creative execution, 360 marketing channel planning, and post-campaign analysis.</li><li><b>Ideate &amp; execute the communication derivatives for diverse marketing distributions</b>, including but not limited to in-app, performance ads, social media, and other out-app touchpoints.</li><li><b>Work on ad-hoc partnership projects</b> and assignments with the most efficient execution.</li><li><b>Monitoring &amp; tracking</b> consistently project performance to give clear updates as well as pointing out learnings &amp; recommendations for improvement</li>"},{"text":"What you will need","content":"<li>Bachelor's degree from a reputable university or equivalent practical experience.</li><li>At least 2 years of experience working in a brand/product marketing &amp; merchant marketing or strategy &amp; planning role in the <b>technology, telecommunication, or start-up </b>industry.</li><li>Proven experience as a <b>marketing executive</b> or similar role</li><li>Good communication skills with prior project management experience</li><li>Strong organizational &amp; time-management abilities</li><li>Superb team player, able to work with all levels to achieve business objective</li><li>Excellent verbal, negotiation, and written interpersonal skills, with the ability to communicate clearly and effectively with team members</li>"}],"text":"Sr. Marketing Executive - Brand Campaign","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Fasten your helmet and climb aboard, if you’re ready to be our Sr. Marketing Executive - Brand Campaign for GoFood. In this role, you will be part of the GoFood Business &amp; Ads team based in Jakarta, Indonesia. Managing campaign strategy and executing go-to-market strategy for our brand thematic and merchant promotional campaigns. This role is crucial in planning &amp; implementing campaign plans such as communication strategy, content development and media placement. The folks in the Sales, Product, Data &amp; Insights, Performance and Creative teams will be your companions.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nFasten your helmet and climb aboard, if you’re ready to be our Sr. Marketing Executive - Brand Campaign for GoFood. In this role, you will be part of the GoFood Business & Ads team based in Jakarta, Indonesia. Managing campaign strategy and executing go-to-market strategy for our brand thematic and merchant promotional campaigns. This role is crucial in planning & implementing campaign plans such as communication strategy, content development and media placement. The folks in the Sales, Product, Data & Insights, Performance and Creative teams will be your companions.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/baf1c074-dffd-41d9-ad55-796428e4d1c8","applyUrl":"https://jobs.lever.co/GoToGroup/baf1c074-dffd-41d9-ad55-796428e4d1c8/apply"},{"additionalPlain":"About the Team\n\nOur Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nTransport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)  using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Transport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)&nbsp; using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717676182978,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","id":"22ac4805-bcbe-4698-9e51-cb25754ac244","lists":[{"text":"What You Will Do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Actively mentor SE/ASEs&nbsp; in the team</li><li>Translate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environments</li><li>Improve engineering standards, tooling and processes</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applications</li><li>Have expertise in at least one of Go or Java</li><li>In-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etc</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"Sr. Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244","applyUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244/apply"},{"additionalPlain":"About the team\n\nThe partnerships team is responsible for building strong relationships with key partners to help Gojek increase brand awareness, attain new customers, and generate new revenue. We work with all business units and functions across Gojek to establish mutually beneficial partnerships that are both product-centric and commercially sound to enhance our consumer’s experience and/or generate additional revenue for the group.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the team</b></div><div><br></div><div>The partnerships team is responsible for building strong relationships with key partners to help Gojek increase brand awareness, attain new customers, and generate new revenue. We work with all business units and functions across Gojek to establish mutually beneficial partnerships that are both product-centric and commercially sound to enhance our consumer’s experience and/or generate additional revenue for the group.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713233450903,"descriptionPlain":"About the Role \n\nAs a strategic partnership lead, you will maintain and build Gojek’s relationship with key partners to increase brand awareness and attain new customers, and new revenue. You will gain hands-on exposure with external partners and internal stakeholders to drive a significant impact on the group's key objectives. \nThis role will be based in Indonesia and will report directly to the Head of Partnerships. Your market knowledge combined with your experienced commercial and communication skills, together with analytical abilities, will enable you to support building and maintaining impactful long-term partnerships, primarily with new partners.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>As a strategic partnership lead, you will maintain and build Gojek’s relationship with key partners to increase brand awareness and attain new customers, and new revenue. You will gain hands-on exposure with external partners and internal stakeholders to drive a significant impact on the group's key objectives.&nbsp;</div><div>This role will be based in Indonesia and will report directly to the Head of Partnerships.&nbsp;Your market knowledge combined with your experienced commercial and communication skills, together with analytical abilities, will enable you to support building and maintaining impactful long-term partnerships, primarily with new partners.</div><div><br></div><div><br></div>","id":"2df4ac6b-ceba-41e5-a8de-42ebe6d20fa2","lists":[{"text":"What you will do","content":"<li>Manage and grow existing partnerships with key strategic partners and key accounts for Gojek within financial institutions, telcos, and retail industries</li><li>Drive the end-to-end strategic business development initiatives - identifying the potential collaboration areas, formulating the partnership strategy, and ensuring the strategic commitments are fully optimized and delivered</li><li>Lead the research, identification, prioritization, and execution of new partnership opportunities to help Gojek achieve increased brand awareness, new customers, and new revenue</li><li>Translate the partnership ideation and objectives into a joint business plan between Gojek's business unit with key strategic partners</li><li>Execute the project implementation &amp; coordination with both internal and external stakeholders by developing an efficient framework for seamless team collaboration, which includes aligning project prioritization, timeline, and problem-solving</li><li>Review and analyze the performance of partnerships after each campaign and advise opportunities for improvements &amp; further developments.</li><li>Be the point of coordination between Gojek product-function groups and key partners</li>"},{"text":"What you will need","content":"<li>At least 6 years of relevant work experience in strategic partnerships/business development with a strong track record of establishing and implementing such partnerships</li><li>Results-oriented and data-driven: Able to make data-informed decisions for a strategic partnership. Proven track record of utilizing data in forming innovative and interesting ideas that are successfully operationalized into impactful partnership campaign execution</li><li>Resourceful and creative problem-solving skills: Knack for identifying great partnership initiatives</li><li>Creative, persistent, and outgoing personality who is eager to learn</li><li>Proactive, positive, and self-motivated with the ability to work without close supervision</li><li>Excellent communication, negotiation, and reporting skills</li><li>Good business network in Indonesia.</li>"}],"text":"Strategic Partnerships Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>As a strategic partnership lead, you will maintain and build Gojek’s relationship with key partners to increase brand awareness and attain new customers, and new revenue. You will gain hands-on exposure with external partners and internal stakeholders to drive a significant impact on the group's key objectives.&nbsp;</div><div>This role will be based in Indonesia and will report directly to the Head of Partnerships.&nbsp;Your market knowledge combined with your experienced commercial and communication skills, together with analytical abilities, will enable you to support building and maintaining impactful long-term partnerships, primarily with new partners.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAs a strategic partnership lead, you will maintain and build Gojek’s relationship with key partners to increase brand awareness and attain new customers, and new revenue. You will gain hands-on exposure with external partners and internal stakeholders to drive a significant impact on the group's key objectives. \nThis role will be based in Indonesia and will report directly to the Head of Partnerships. Your market knowledge combined with your experienced commercial and communication skills, together with analytical abilities, will enable you to support building and maintaining impactful long-term partnerships, primarily with new partners.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2df4ac6b-ceba-41e5-a8de-42ebe6d20fa2","applyUrl":"https://jobs.lever.co/GoToGroup/2df4ac6b-ceba-41e5-a8de-42ebe6d20fa2/apply"},{"additionalPlain":"About the Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\n\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</span></div><div><br></div><div><span style=\"font-size: 16px\">We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717559195275,"descriptionPlain":"About The Role\n\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","id":"8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","lists":[{"text":"What You Will Do","content":"<li>Help provide clarity and direction for marketing campaigns or initiatives</li><li>To become the bridge between the Creatives and the marketing, media, social, design, product and research team</li><li>Always bringing the consumer perspective into the creative process in Gojek by simply staying in touch with society and the trends that are changing it</li>"},{"text":"What You Will Need","content":"<li>You have at least 5 years of strategy experience in an agency or related environment</li><li>Ability to deliver a clear, insight-based strategic recommendation in the form of a written brief</li><li>Ability to support Creatives and Designers&nbsp; with relevant stimulus, routes, or advice</li><li>Ability to visualize simple customer journeys in clear &amp; compelling ways</li>"}],"text":"Strategic Planner - Creative Labs - #10088","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px;\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","descriptionBodyPlain":"About The Role\n\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","applyUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713867338946,"description":"","descriptionPlain":"","id":"afb5bc40-aa4f-4837-a2d9-7d38eade2599","lists":[{"text":"What will you do","content":"<li>Assume ownership of key performance indicators (KPIs) driving revenue and profitability for Consumer Lending <a href=\"http://business.Develop\" class=\"postings-link\">business.</a></li><li><a href=\"http://business.Develop\" class=\"postings-link\">Develop</a> comprehensive strategies and roadmaps to achieve growth objectives through a combination of <a href=\"http://initiatives.Identify\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Identify\" class=\"postings-link\">Identify</a> growth opportunities within the consumer lending business by analyzing business data, transactional data, customer activity within platforms, and leveraging customer <a href=\"http://insights.Lead\" class=\"postings-link\">insights.</a></li><li><a href=\"http://insights.Lead\" class=\"postings-link\">Lead</a> the prioritization process, strategizing, and focusing on solutions aimed at addressing user needs and enhancing user <a href=\"http://experience.Validate\" class=\"postings-link\">experience.</a></li><li><a href=\"http://experience.Validate\" class=\"postings-link\">Validate</a> business strategies and hypotheses through rigorous experimentation and statistical <a href=\"http://methodologies.Present\" class=\"postings-link\">methodologies.</a></li><li><a href=\"http://methodologies.Present\" class=\"postings-link\">Present</a> findings and insights to senior management to inform strategic decision-making regarding feature prioritization and impact <a href=\"http://analysis.Cultivate\" class=\"postings-link\">analysis. </a></li><li><a href=\"http://analysis.Cultivate\" class=\"postings-link\">Cultivate</a> and manage partnerships with external stakeholders.</li>"},{"text":"What will you need","content":"<li>BS/MS in Business, Engineering, Computer Science, Math, Economics, Statistics, or <a href=\"http://equivalent.8-10\" class=\"postings-link\">equivalent.</a></li><li><a href=\"http://equivalent.8-10\" class=\"postings-link\">8-10</a> years of working experience with strong business <a href=\"http://acumen.End\" class=\"postings-link\">acumen.</a></li><li><a href=\"http://acumen.End\" class=\"postings-link\">End</a> to end problem-solving mindset that can work in increments and <a href=\"http://exponents.Strong\" class=\"postings-link\">exponents.</a></li><li><a href=\"http://exponents.Strong\" class=\"postings-link\">Strong</a> project management skills to manage complex projects, also can manage and prioritize multiple internal and external <a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">Proficiency</a> in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with good knowledge of SQL and experimentation processHustle is essential, moving quickly and executing to allow for continual iteration is a core competency of the teamExperience in a financial services and technology companies is preferred.</li>"}],"text":"Strategy Senior Manager, Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599","applyUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599/apply"},{"additionalPlain":"Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1709264557847,"descriptionPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","description":"<div><span style=\"font-size: 10pt\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","id":"eaab5bee-084d-4cdc-bd08-63230251009c","lists":[{"text":"What you will do","content":"<li>Develop and maintain supply related dashboards to monitor key metrics and compare achievements against targeted <a href=\"http://goals.Analyze\" class=\"postings-link\">goals.</a></li><li><a href=\"http://goals.Analyze\" class=\"postings-link\">Analyze</a> various data points, detect anomalies and spot trends to drive business and strategic decision-making on supply <a href=\"http://initiatives.Collaborate\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Collaborate\" class=\"postings-link\">Collaborate</a> with the BI, Data Science, Marketing, and Product Management teams to ensure alignment on data analysis, methodologies, insights, and recommendations and proactively escalate issues to relevant <a href=\"http://stakeholders.Analysis\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Analysis\" class=\"postings-link\">Analysis</a> on the competitive intelligence insights and <a href=\"http://findings.Be\" class=\"postings-link\">findings.</a></li><li><a href=\"http://findings.Be\" class=\"postings-link\">Be</a> the go-to person on anything related to the supply health metrics and analysis.</li><div><br></div>"},{"text":"What you will need","content":"<li>A BS/MS in Business, Engineering, Computer Science, Mathematics, Economics or equivalent experience</li><li>3+ years of experience within one or more of the following fields: Business Analytics, Strategy and Planning, Growth or relevant functions</li><li>Comfortable analyzing large amounts of raw data with an obsession to detail and accuracy of data</li><li>Able to uncover the story and relationship behind the numbers and communicate the insights to a wider audience</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Proficiency in multiple analytic, database, and visualization tools (e.g., Tableau, Looker Studio, etc.) along with strong knowledge of SQL</li><li>A scientific and hypothesis-driven thinking process with the ability to work in increments and exponents</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders </li><div><br></div>"}],"text":"Supply Strategy Data Analyst [Ads]","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","descriptionBodyPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c","applyUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c/apply"},{"additionalPlain":"About the Team\n\nOur team is a dynamic and collaborative group of individuals who are passionate about driving transformation at GoTo. We work in a fast-paced environment, but we always make time for collaboration and knowledge sharing. We are committed to fostering a culture of continuous learning and development, and we encourage our team members to take ownership of their work and contribute to our collective success.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Our team is a dynamic and collaborative group of individuals who are passionate about driving transformation at GoTo. We work in a fast-paced environment, but we always make time for collaboration and knowledge sharing. We are committed to fostering a culture of continuous learning and development, and we encourage our team members to take ownership of their work and contribute to our collective success.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717653703671,"descriptionPlain":"About The Role\n\nThe Transformation Office Manager is a pivotal role within GoTo, working closely with the Hold Co COO and all business units. You will be instrumental in driving the development and implementation of Hold Co OKRs, ensuring alignment with strategic goals. Your responsibilities encompass tracking operating performance across GoTo, identifying areas for improvement, and communicating insights to stakeholders. This role is both challenging and rewarding, requiring strong analytical skills, stakeholder management, and the ability to synthesize complex data into actionable insights. In the first six months, you will significantly impact GoTo's performance by streamlining OKR processes, providing data-driven recommendations, and fostering cross-functional collaboration.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">The Transformation Office Manager is a pivotal role within GoTo, working closely with the Hold Co COO and all business units. You will be instrumental in driving the development and implementation of Hold Co OKRs, ensuring alignment with strategic goals. Your responsibilities encompass tracking operating performance across GoTo, identifying areas for improvement, and communicating insights to stakeholders. This role is both challenging and rewarding, requiring strong analytical skills, stakeholder management, and the ability to synthesize complex data into actionable insights. In the first six months, you will significantly impact GoTo's performance by streamlining OKR processes, providing data-driven recommendations, and fostering cross-functional collaboration.</span></div>","id":"2c5a98c2-e5f9-4fbf-a710-9ac6ca9a561a","lists":[{"text":"What You Will Do","content":"<li>Collaborate with the HoldCo COO team and business unit leaders to define and refine Hold Co OKRs and initiatives</li><li>Analyze data from various sources to identify trends, opportunities, and potential risks</li><li>Prepare comprehensive reports and presentations to communicate findings to stakeholders</li><li>Facilitate regular meetings to review OKR progress and discuss performance improvement strategies</li><li>Drive cross-functional collaboration to ensure alignment and accountability across business units</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree in business, economics, or a related field</li><li>5+ years of experience in management consulting, business analysis, or a similar role</li><li>Strong analytical skills and the ability to synthesize complex data into actionable insights</li><li>Proficiency in SQL and familiarity with big data tools and techniques</li><li>Excellent communication and presentation skills, both written and verbal</li><li>Strong stakeholder management and interpersonal skills</li><li>Ability to work independently and collaboratively in a fast-paced environment</li><li>Proven track record of driving results and delivering on commitments</li><li>Passion for data-driven decision-making and continuous improvement</li>"}],"text":"Transformation Office Manager - #10098","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">The Transformation Office Manager is a pivotal role within GoTo, working closely with the Hold Co COO and all business units. You will be instrumental in driving the development and implementation of Hold Co OKRs, ensuring alignment with strategic goals. Your responsibilities encompass tracking operating performance across GoTo, identifying areas for improvement, and communicating insights to stakeholders. This role is both challenging and rewarding, requiring strong analytical skills, stakeholder management, and the ability to synthesize complex data into actionable insights. In the first six months, you will significantly impact GoTo's performance by streamlining OKR processes, providing data-driven recommendations, and fostering cross-functional collaboration.</span></div>","descriptionBodyPlain":"About The Role\n\nThe Transformation Office Manager is a pivotal role within GoTo, working closely with the Hold Co COO and all business units. You will be instrumental in driving the development and implementation of Hold Co OKRs, ensuring alignment with strategic goals. Your responsibilities encompass tracking operating performance across GoTo, identifying areas for improvement, and communicating insights to stakeholders. This role is both challenging and rewarding, requiring strong analytical skills, stakeholder management, and the ability to synthesize complex data into actionable insights. In the first six months, you will significantly impact GoTo's performance by streamlining OKR processes, providing data-driven recommendations, and fostering cross-functional collaboration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2c5a98c2-e5f9-4fbf-a710-9ac6ca9a561a","applyUrl":"https://jobs.lever.co/GoToGroup/2c5a98c2-e5f9-4fbf-a710-9ac6ca9a561a/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705901801143,"descriptionPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","description":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","id":"17408b81-f5a0-4f15-afae-cc04ed7e43b6","lists":[{"text":"What You Will Do","content":"<li>Prepare Risk reporting and position reporting</li><li>Conduct assessments to define and analyze possible risks</li><li>Evaluate the gravity of each risk by considering its consequences</li><li>Design processes to eliminate or mitigate potential risks</li><li>Evaluate existing policies and procedures to find weaknesses</li><li>Prepare reports and present recommendations</li><li>Ensure risk exposures of the company is within stipulated limits</li><li>Work closely with other business stakeholders</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years&nbsp;</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal and external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL will be an advantage</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Underwriting and Credit Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","descriptionBodyPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6","applyUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6/apply"},{"additionalPlain":"About The Team\n\nThe design team consists of Motion designers, Creative designers, Product designers, Interaction Designers, UX Writers, and DesignOps.The motion designers bring the UI to life by creating intuitive and smooth screen transitions, micro interactions, and animating static illustrations, icons and logos when needed.\n\nEvery member of the team blends in and works together as a family to support and nurture the growth of our team, and the organization as a whole.\n\nAs motion designers, we work with the Design system team, illustrators, graphic designers, UX writers, engineers and product designers to combine the principles of usability, accessibility, consistency and aesthetics to craft an experience that our users can call delightful.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The design team consists of Motion designers, Creative designers, Product designers, Interaction Designers, UX Writers, and DesignOps.The motion designers bring the UI to life by creating intuitive and smooth screen transitions, micro interactions, and animating static illustrations, icons and logos when needed.</div><div><br></div><div>Every member of the team blends in and works together as a family to support and nurture the growth of our team, and the organization as a whole.</div><div><br></div><div>As motion designers, we work with the Design system team, illustrators, graphic designers, UX writers, engineers and product designers to combine the principles of usability, accessibility, consistency and aesthetics to craft an experience that our users can call delightful.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Design","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1706869832934,"descriptionPlain":"About The Role\n\nOur Motion Designers bring the UI to life by creating intuitive and smooth screen transitions, micro-interactions, and animating static illustrations, icons, and logos when needed. While the most common use of motion is to bring some life and delight to the user’s experience of navigating through user interfaces, it can also help prevent blindness to change and reduce cognitive load. Our vision is to drive motion design to be an essential and unique part of the Gojek user experience.\n\nAs a UX Motion Designer, you will be building the most delightful and intuitive user experiences for our users. You will be working with a team of passionate motion designers and be responsible for making the product experience buttery smooth, using the power of motion design.\n\n","description":"<div><b>About The Role</b></div><div><br></div><div>Our Motion Designers bring the UI to life by creating intuitive and smooth screen transitions, micro-interactions, and animating static illustrations, icons, and logos when needed. While the most common use of motion is to bring some life and delight to the user’s experience of navigating through user interfaces, it can also help prevent blindness to change and reduce cognitive load. Our vision is to drive motion design to be an essential and unique part of the Gojek user experience.</div><div><br></div><div>As a UX Motion Designer, you will be building the most delightful and intuitive user experiences for our users. You will be working with a team of passionate motion designers and be responsible for making the product experience buttery smooth, using the power of motion design.</div><div><br></div>","id":"6aac2e66-88b7-46a3-9c91-605a33dc532d","lists":[{"text":"What You Will Do","content":"<li>Work closely with Product designers and Interaction designers to discuss the possible solutions for a problem</li><li>Transform those ideas into production-ready solutions using UI transitions, micro-interactions, and character animations</li><li>Work closely with the developers to implement those ideas as envisioned</li><li>Work on tools and documentation to improve the process of motion design</li><li>Help evangelize the significance of motion design across the team by engaging in discussions with other designers and stakeholders and promoting open discussions</li><li>Work on new and experimental streams for motion design as and when they are needed</li><li>Work on the motion design for Gojek’s Aloha Design System to add micro-interactions and transitions to components and work with the design system team to improve the system and animations</li>"},{"text":"What You Will Need","content":"<li>At least 1 year of experience working in motion design - creating Motion Graphics and UI Animations</li><li>A portfolio that demonstrates a deep understanding of micro-interactions, micro-animations, UI animations, and character animations</li><li>Solid grasp of Adobe after effects (Brownie points for expertise in other tools such as&nbsp; protopie, Figma, Rive, etc) and experience working with Lottie JSON animations</li><li>A natural curiosity and interest in picking up and learning new tools and technologies in motion design</li><li>Ability and willingness to work with Designers and Researchers to understand project requirements</li><li>Strong command of visual and communication design principles</li><li>Ability to tell stories with motion, and pitch them to stakeholders from different backgrounds</li><li>A keen awareness of visual trends associated with entertainment, gaming, and particularly in mobile app spaces. Experience in designing for these industries would be good to have.</li><li>Should be able to communicate effectively in English</li>"}],"text":"UX Motion Designer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Our Motion Designers bring the UI to life by creating intuitive and smooth screen transitions, micro-interactions, and animating static illustrations, icons, and logos when needed. While the most common use of motion is to bring some life and delight to the user’s experience of navigating through user interfaces, it can also help prevent blindness to change and reduce cognitive load. Our vision is to drive motion design to be an essential and unique part of the Gojek user experience.</div><div><br></div><div>As a UX Motion Designer, you will be building the most delightful and intuitive user experiences for our users. You will be working with a team of passionate motion designers and be responsible for making the product experience buttery smooth, using the power of motion design.</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nOur Motion Designers bring the UI to life by creating intuitive and smooth screen transitions, micro-interactions, and animating static illustrations, icons, and logos when needed. While the most common use of motion is to bring some life and delight to the user’s experience of navigating through user interfaces, it can also help prevent blindness to change and reduce cognitive load. Our vision is to drive motion design to be an essential and unique part of the Gojek user experience.\n\nAs a UX Motion Designer, you will be building the most delightful and intuitive user experiences for our users. You will be working with a team of passionate motion designers and be responsible for making the product experience buttery smooth, using the power of motion design.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6aac2e66-88b7-46a3-9c91-605a33dc532d","applyUrl":"https://jobs.lever.co/GoToGroup/6aac2e66-88b7-46a3-9c91-605a33dc532d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Shared Service, Design","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711601639371,"description":"","descriptionPlain":"","id":"ea17a902-a106-48ab-be52-08ce99f99b4b","lists":[{"text":"What You Will Do ","content":"<li>Lead the content designing process in assigned streams involving stakeholders from Designers, Researchers, Illustrators, Product Managers, Business Teams, Marketing, Legal, and others, following the pre-defined processes but also able to identify rooms for improvement during the processes</li><li>Effectively deliver features and improvements per agreed mass timelines with high-quality output</li><li>Strategize for how Gojek better communicates to its users</li><li>Contribute to team discussions in improving collective quality output&nbsp;</li><li>Closely and intensely collaborate and communicate with stakeholders in given contexts such as: gathering feedback, aligning thoughts to reach an agreement, giving feedback to stakeholders, resolving conflicts, and so on.</li>"},{"text":"What You Will Need","content":"<li>Proficient in English and Indonesian grammar. Have a knack for languages and their role in society, daily conversation, device-mediated communication, and others</li><li>Excellent understanding of writing fundamentals, such as structured thinking, critical and creative thinking, context gathering, research, problem-solving, seeking feedback, and prioritization</li><li>Able to think beyond common structures, but generate original ideas and craft copywriting</li><li>Strong self-driven purpose of work and possess a high initiative of doing what’s right and not what’s easy</li><li>A rich understanding of Indonesians and how they go about their daily lives</li><li>Fearlessness in getting your hands dirty to find out root causes, or to validate your design, through qualitative and quantitative research</li><li>Remarkable communication in collaborating with stakeholders and advocating your work</li><li>Confident and independent self-management, project management, and leadership</li>"}],"text":"UX Writer - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/ea17a902-a106-48ab-be52-08ce99f99b4b","applyUrl":"https://jobs.lever.co/GoToGroup/ea17a902-a106-48ab-be52-08ce99f99b4b/apply"},{"additionalPlain":"About the Team \n\nThe Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b><span style=\"font-size: 16px\">&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1715929009192,"descriptionPlain":"About the Role\n\nIf you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Vendor Manager, you'll oversee the day-to-day activities, metrics, and performance of our outsourced contact center operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. \n\nThis position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Vendor Manager, you'll oversee the day-to-day activities, metrics, and performance of our outsourced contact center operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. </span></div><div><br></div><div><span style=\"font-size: 16px\">This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","id":"8b9f79f1-25ac-45cd-b2a1-98a4e7217644","lists":[{"text":"What You Will Do:","content":"<li>Establish, maintain, and supervise relationships with our BPO contact center, focusing on efficiency and cost-effectiveness</li><li>Conduct regular evaluations of vendor performance to ensure compliance with contractual obligations and service level agreements</li><li>Collaborate with internal and external stakeholders to ensure alignment of goals and effective communication channels</li><li>Use performance metrics to pinpoint areas for improvement, implement necessary corrections, and regularly produce detailed reports on vendor performance, risks, opportunities, and relevant metrics</li><li>Travel to BPO vendor sites for assessments, meetings, and relationship building</li><li>Stay updated on industry trends, driving innovation in BPO management and ensuring competitiveness</li><li>Facilitate effective communication across the team, encouraging feedback and customer insights to enhance the customer experience</li><li>Promote best practices, processes, and systems, fostering a culture of continuous improvement within the BPO</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of working experience as an operations manager in a contact center or in a vendor management role</li><li>Complete understanding of contact center operations, efficiency models, key performance indicators and contributing factors</li><li>Capable of making or guiding decisions regarding staffing, systems, and operational requirements for the BPO contact center</li><li>Structured, proven ability to meet deadlines, manage multiple priorities and achieve results through strong stakeholder and project management skills</li><li>Exceptional interpersonal, customer service, problem-solving, verbal and written communication skills</li><li>Decisive with excellent attention to detail, possessing strong analytical skills and structured thinking process</li><li>Ability to travel to visit BPO vendor (25%)</li>"}],"text":"Vendor Manager","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Vendor Manager, you'll oversee the day-to-day activities, metrics, and performance of our outsourced contact center operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. </span></div><div><br></div><div><span style=\"font-size: 16px;\">This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","descriptionBodyPlain":"About the Role\n\nIf you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Vendor Manager, you'll oversee the day-to-day activities, metrics, and performance of our outsourced contact center operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. \n\nThis position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8b9f79f1-25ac-45cd-b2a1-98a4e7217644","applyUrl":"https://jobs.lever.co/GoToGroup/8b9f79f1-25ac-45cd-b2a1-98a4e7217644/apply"}]
-  recorded_at: Thu, 27 Jun 2024 13:37:13 GMT
+        [{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721638994130,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","id":"f53cae40-f605-4215-9a82-b48c5db508b5","lists":[{"text":"What you will do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance.</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Actively mentor SE/ASEs&nbsp; in the teamTranslate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environmentsImprove engineering standards, tooling and processes</li>"},{"text":"What you will need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applicationsHave expertise in at least one of Go or JavaIn-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etcExcellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"#10010 Senior Backend Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5","applyUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5/apply"},{"additionalPlain":"The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.\nThe Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.\nWe, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.\n","additional":"<div><span style=\"font-size: 10pt\">The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 10pt\">The Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.</span></div><div><span style=\"font-size: 10pt\">We, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721640901865,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","id":"ce351965-e2f9-4f8f-8cad-38fb4cd045e9","lists":[{"text":"What you will do","content":"<li>Independently responsible for the entire lifecycle of high-complexity Android projects or features including software design, development, and deployment within their team</li><li>Planning &amp; timely delivery of work within their teamImproving code structure and architecture in service of testability and maintainability</li><li>Writing, co-writing, and reviewing design documentation</li><li>Leading new language/framework POCsParticipating in the design review process, seeking and providing constructive criticism</li><li>Tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Ensuring that their team has strong sets of documentation and journals of how their design and architecture evolve over time</li><li>Ensuring predictability, quality &amp; throughput of their team's delivery</li><li>Prioritizing and valuing work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalating challenges that are outside their control but affect the team's delivery</li><li>Prioritizing work based on understanding the trade-off between quality, tech-debt, and delivery</li><li>Leading effort to work with other teams to solve problems affecting the delivery of their team</li><li>Participating in prioritization of cross teams initiatives &amp; leading those within their own team</li><li>Splitting complex engineering task into smaller components which can be developed by junior engineers in the team</li><li>Mentoring other engineers on an individual basis</li><li>Participating in the hiring process (by meeting candidates, and attending recruiting events)</li><li>Conducting engineering interviews</li>"},{"text":"What you will need","content":"<li>Should have at least 4 years of experience with Android developmentProficient in Kotlin programming, Java, and Android APIs.</li><li>Strong knowledge of Android Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standards across the teamWorking experience with popular libraries for networking, async, image loading, etc.</li><li>Well-versed with Agile methodologies, TDD, and Test Engineering &amp; Automation.</li><li><b>Bonus points if:&nbsp;</b>Have experience in Running A/B or multi-variant experiments for features that you built.</li>"}],"text":"#10279 Senior Android Developer (Logistic)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9","applyUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898011592,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"657d7112-420a-4e42-8bfd-1b790fc05155","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"#10357 Senior Software Engineer - Go-food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155","applyUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721901545426,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"87b4d0e4-219e-4ba7-9433-27220623ab69","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10358 Software Engineer - Backend (Groceries)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69","applyUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898703682,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10359 Software Engineer - Backend","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","applyUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</div>","categories":{"department":"ODS - Regions","location":"Bali","team":"East Java, Bali, Nusra Regions","allLocations":["Bali"]},"createdAt":1720778770433,"descriptionPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"73172a46-5486-4860-a256-8e17225c4a47","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transaction</li><li>Create regular report to what's happen in their respective areas toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Fresh Graduate are welcome to Apply&nbsp;</li><li>2 years relevant experience with preferable industries: top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region will be a plus</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Bali)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47","applyUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721704703939,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"885b2af9-c94a-4010-b0c4-c6ea7812039b","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b","applyUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721037961422,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"94efd0c8-e79b-41e1-aa37-a7a4c08c108f","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f","applyUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f/apply"},{"additionalPlain":"About the team\n\nOur GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n","additional":"<div><b>About the team</b></div><div><br></div><div>Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</div><div><br></div><div>Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</div>","categories":{"department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721623842937,"descriptionPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","id":"94f85d13-6fe6-43a8-96c8-4898ab75d908","lists":[{"text":"What Will You Do","content":"<li>Executing campaign creation of our merchants through our inhouse portal and assist in troubleshooting to our product managers and engineers&nbsp;</li><li>Proactively improve the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Learn to introduce beneficial business changes through well-written document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Support and coordinate with multiple stakeholders to ensure seamless workflow, update relevant changes and address any operational issues</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resources</li>"},{"text":"What Will You Need","content":"<li>Minimum 1 year of working experience&nbsp;</li><li>End to end the problem-solving mindset that can work well with stakeholders&nbsp;</li><li>Basic data analytics capability, having capability in SQL is a plus</li><li>Experience in Growth, Product Management, and Data team is a plus</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders&nbsp;</li><li>Open to acquiring new skills and taking on diverse projects</li>"}],"text":"Ads Ops Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","descriptionBodyPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908","applyUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908/apply"},{"additionalPlain":"About The Team\nArea CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales & analytics team) in the designated Areas.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Area CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales &amp; analytics team) in the designated Areas.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Semarang","team":"Central West Java Regions","allLocations":["Semarang"]},"createdAt":1720592465974,"descriptionPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","id":"f1bdce17-4ab5-49ab-9dbc-6d96a5619846","lists":[{"text":"What You Will Do","content":"<li>Support Area Head to drive consumer engagement focus areas in terms of Visibility &amp; Partnership which will deliver POI domination, POS merchants branding, standard package that will deliver Area target completed orders and active users</li><li>Managing all day to day marketing executional activities from all areas needed to deliver the consumer engagement plans. e.g. contract, PO, invoice, etc.</li><li>Ensure all consumer engagement activities in areas are delivered with a given standard of accuracy, completeness, timeliness as per the standard package and local initiatives</li><li>Externally supervise vendors/daily workers in executing merchant branding and POI domination on a regular basis</li><li>&nbsp;Internally work with direct responsibility to deliver area executions and targets by executing events, exhibits, and other activities</li><li>Good with data to develop and execute clear integrated strategies of digital marketing with clear metrics and excellent results</li><li>Responsible for setting the integrated communications plan and ensuring consistency of messaging and brand communications. Working closely with the sales, government relations, and operations team</li>"},{"text":"What This Role Needs","content":"<li>At least 2&nbsp; years of working experience in Marketing/Sales</li><li>Good understanding of local knowledge</li><li>Strong analytical and planning skills</li><li>Good communication and presentation skills</li><li>Excellent problem-solving skill with the ability to play it well independently and in a team</li><li>Good collaboration with compassion and proactiveness</li><li>Agile and fast in thinking and execution</li><li>Have exposure of working at a top global FMCG company would be a plus point</li>"}],"text":"Area CE Associate - Semarang - #10227","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","descriptionBodyPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846","applyUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720169838701,"descriptionPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><span style=\"font-size: 10pt\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","lists":[{"text":"What you will do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;</li><li>driver acquisition management</li><li>driver engagement management (loyalty &amp; retention and safety &amp; performance training)&nbsp;</li><li>driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant)</li><li>driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li><div><br></div>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Having good understanding about supply and demand planning</li><li>Having experience in managing a small team (&gt; 3 members)</li><li>Having good communication skills and good attention to detail and routine activities</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Able to handle communication in community or mass conflict&nbsp;</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written in English</li>"}],"text":"Area Operations Manager - Bekasi","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","applyUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb/apply"},{"additionalPlain":"About the team \n\nArea Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the team </b></div><div><br></div><div><span style=\"font-size: 16px\">Area Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Depok","team":"-","allLocations":["Depok","Bogor"]},"createdAt":1713768982209,"descriptionPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"18674f77-24b2-46a4-86bb-7b5e7fe71f2c","lists":[{"text":"What You Will Do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;Driver acquisition management, Driver engagement management (loyalty &amp; retention and safety &amp; performance training), Driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant), driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li>"},{"text":"What You Will Need","content":"<li>At least 5 years experience in operations/ supply/ demand generation, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Good understanding about supply and demand planning</li><li>Prior experience in managing team (&gt; 3 members)</li><li>Good communication skills and good attention to detail and routine activities</li><li>Ability to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Capability to handle communication in community or mass conflict&nbsp;</li><li>Proficiency in English both spoken and written</li>"}],"text":"Area Operations Manager (Bogor Depok)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c","applyUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c/apply"},{"additionalPlain":"About The Team\n\nOur Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners. \n\nOne of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team. \n\nOur team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">One of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"-","allLocations":["Tangerang"]},"createdAt":1716869065162,"descriptionPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","id":"8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","lists":[{"text":"What You Will Do","content":"<li>List, identify, and propose solutions to our driver partners' problems on the field and ensure their concerns are heard by following up with them</li><li>Manage offline engagement (i.e. 'kopdar') as our way to inform, reach, and engage with driver partners</li><li>Ensure all engagement programs are well executed and implemented</li><li>Handle driver support unit according to agreed operating office hours</li><li>Support implementation of Gojek's policies/programs by managing these changes</li><li>Propose activities/programs to engage our driver partners</li><li>Monitor personal metrics of engagement with driver partners, and propose solutions to increase the level of engagement</li>"},{"text":"What You Will Need","content":"<li>A Bachelor's degree (fresh graduates are welcome to apply!)</li><li>At least 1 year of experience in supply chain, preferably at a multinational company</li><li>Strong analytical thinking and problem-solving skills to effectively resolve driver-related issues</li><li>Strong interpersonal skills in order to cater and build relationships with various stakeholders</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Sharp attention to detail to increase productivity and reduce the likelihood of errors</li><li>Excellent planning and organizational abilities to ensure the area team is on track to achieve its goals</li><li>An understanding about/familiarity with the Tangerang region</li>"}],"text":"Area Operations Staff","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","descriptionBodyPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","applyUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2/apply"},{"additional":"","additionalPlain":"","categories":{"department":"ODS - Regions","location":"Balikpapan","team":"Emerging Market","allLocations":["Balikpapan"]},"createdAt":1719223321521,"description":"","descriptionPlain":"","id":"95ee9a06-a46d-43a2-a8e7-003de776404d","lists":[{"text":"What you will do:","content":"<li>Handle all the driver community, marketing, and driver care responsibilities on areas level and channel walk in center on each area;</li><li>Ensure problem solving according to agreed process &amp; based on standard operational procedure;</li><li>Manage driver’s problems and empowerment;</li><li>Coordinate with Area Operations Manager for day-to-day escalated issues around driver service and customer service to manage service time, driver and customer satisfaction;</li><li>Developing the marketing strategy for the company in line with company objectives;</li><li>Conceptualizes events, exhibits and other below the line marketing based on the marketing plan, and evaluate the effectiveness of all marketing activities;</li><li>Maintain effective internal communications to ensure that all relevant company functions are kept informed of marketing objectives.</li>"},{"text":"What you will need:","content":"<li>Having a minimum of 3 years experience in related fields;</li><li>Bachelor degree from top university any well-known universities from each region with GPA &gt; 3.2 or equivalent;</li><li>Passionate about community development, having relevant previous experience would be preferred;</li><li>Experience launching community initiatives (building an online forum, launching an ambassador program, creating an event series, etc.);</li><li>Ability to identify and track relevant community and market metrics;</li><li>Excellent verbal communication and writing skills;</li><li>Having a basic of data analytics;</li><li>Willing to relocate to a selected area.</li>"}],"text":"Area Operations Supervisor - Balikpapan","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d","applyUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d/apply"},{"additionalPlain":"About the team\n\nThis position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team. \n","additional":"<div><b>About the team</b></div><div><br></div><div>This position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team.&nbsp;</div>","categories":{"department":"ODS - Regions","location":"Makassar","team":"Emerging Market","allLocations":["Makassar"]},"createdAt":1721716492787,"descriptionPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","description":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","id":"20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","lists":[{"text":"What Will You Do","content":"<li>Develop and implement procedures for effective sales support administration;</li><li>Monitor and analyze sales support team performance to identify areas for improvement and implement strategies to increase efficiency;</li><li>Ensure all sales inquiries and issues are addressed promptly and accurately, with a focus on improving merchant satisfaction &amp; topline sales metrics;</li><li>Coordinate with the merchant sales team to streamline sales processes and remove obstacles in the sales cycle;</li><li>Execute GoFood onboarding timely &amp; ensure that there is no backlog</li><li>Able to understand KYC follow up reasons based on FAQ and able to know when to escalate</li><li>Collaborate with other departments to ensure sales and marketing strategies are aligned and support the overall goals of the organization;</li><li>Assist in the development and implementation of sales policies and practices that drive sales effectiveness.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree in Business Administration, Marketing, or a related field;</li><li>Minimum of 3 years of experience in sales support, account management, customer service, sales-marketing administration related or a supervisory role within a sales-focused organization;</li><li>Strong customer/merchant partner focus and project management skills preferred;</li><li>Has data reporting skills, preferred both Bahasa Indonesia and English;</li><li>Strong analytical and problem-solving abilities by utilizing e.g. Google Sheet, etc;</li><li>Detail and deadline oriented;</li><li>Strong stakeholder management and cross-functional collaboration;</li><li>Able to adapt in a fast-changed environment.</li>"}],"text":"Area Sales Support Supervisor (Sulampa)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","descriptionBodyPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","applyUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450/apply"},{"additionalPlain":"About The Team\n\nOur tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!  \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">Our tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!&nbsp;&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697204557563,"descriptionPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","description":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","id":"56966262-038f-497f-84c1-f360a9440c55","lists":[{"text":"What You Will Do","content":"<li>Manage tax compliance matters; including preparation of monthly and annual tax calculation/payment/returns, i.e. WHT, VAT, CIT)</li><li>Manage and advise day-to-day business initiatives including decisive actions toward dynamic business products</li><li>Manage and handle restructuring projects independently with supervision from the AVP of Tax</li><li>Able to communicate and align with relevant stakeholders within the group</li><li>Monitoring any tax regulation updates, identifying relevant business areas that may be impacted, and planning the risk mitigation strategy</li><li>Able to support the litigation process and assessment of risks</li><li>Able to support the advocacy initiatives within the relevant external organizations.</li>"},{"text":"What You Will Need","content":"<li>S1 Bachelor of Economics (majoring in accounting or corporate finance) or Bachelor of Social Finance (Majoring in Fiscal Administration) </li><li>Minimum 5 years of working experience in the taxation field</li><li>Strong interpersonal, analytical, communication, and presentation skills with advanced command of written and spoken English</li><li>Strong technical skills in tax, accounting, and corporate finance</li><li>Ability to work in a fast-paced, rapidly changing, and high-growth environment</li><li>Able to work independently and in a team</li>"}],"text":"Assistant Tax Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","descriptionBodyPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55","applyUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721353652294,"descriptionPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","description":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","id":"325ee617-30f3-41c1-a022-6577bd82faf0","lists":[{"text":"What You Will Do","content":"<li>Collecting and importing data from various sources into databases.</li><li>Cleaning and preprocessing data to ensure accuracy and consistency.</li><li>Analyzing datasets to identify trends, patterns, and insights.</li><li>Creating and maintaining data visualizations and dashboards.</li><li>Generating regular and ad-hoc reports for stakeholders.</li><li>Collaborating with team members and stakeholders to understand data needs and requirements.</li><li>Monitoring data quality and integrity, addressing any discrepancies.</li><li>Utilizing programming languages (e.g., SQL, Python) and tools (e.g., Sheet) for data manipulation and analysis.</li>"},{"text":"What You Will Need","content":"<li>Technical Skills: Proficiency in SQL, Python, and Sheet for data manipulation and analysis.</li><li>Analytical Skills: Strong analytical and problem-solving skills to interpret data and create actionable insights.</li><li>Reporting Tools: Familiarity with tools for generating reports, such as Sheet, Metabase, or Looker Studio.</li><li>Communication Skills: Ability to communicate findings and insights effectively to non-technical stakeholders..</li>"}],"text":"Business Analyst - GoPay","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt;\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt;\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","descriptionBodyPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0","applyUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716278898371,"descriptionPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","description":"<div><span style=\"font-size: 16px\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","id":"2242125a-7155-4353-bc79-473d237d6808","lists":[{"text":"What You WIll Do","content":"<li>Be the expert in using data to measure and analyze business performance.</li><li>Explore business issues/opportunities, uncover insights and/or identify targeted areas for business growth.</li><li>Lead new data analytics capability rollouts and/or data-led initiatives throughout organization.</li><li>Monitor key metrics and alert the business on potential issues.</li><li>Analyze operational efficiency and build business models to guide decision-making.</li><li>Design market/business intelligence reports and performance measurement dashboards to share with senior management.</li><li>Able to analyze business performance following the analysis framework.</li><li>Able to create reports/ dashboards individually.</li><li>Collaborates with business stakeholders to gather requirements and deliver actionable insights.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Statistics, Business Administration, or a related field.</li><li>2-5 years of experience in a BI or analytics role.</li><li>Proficiency in SQL and database management systems like MySQL, SQL Server, or Oracle.</li><li>Advanced knowledge of data modeling and data warehousing concepts.</li><li>Strong understanding of business processes and the ability to translate business requirements into technical solutions.</li><li>Familiarity with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Experience with BI reporting tools and dashboard development.</li><li>Proven ability to work with cross-functional teams and manage stakeholders.</li><li>Familiarity with business operations in the field.</li>"}],"text":"Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","descriptionBodyPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808","applyUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808/apply"},{"additionalPlain":"About The Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119647983,"descriptionPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><b style=\"font-size: 16px\">Job Scope</b></div><div><span style=\"font-size: 16px\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px\">6 Months Challenge</b></div><div><span style=\"font-size: 16px\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","id":"9a8977f6-ea32-40e0-bb09-d3330c40d056","lists":[{"text":"What You Will Do","content":"<li>Monitor performance metrics and adjust processes as needed</li><li>Build relationships with stakeholders to support process optimization initiatives</li><li>Leverage technology to automate tasks and improve accuracy</li><li>Focus on enhancing customer experience in building automated support processes</li><li>Ensure high-quality service delivery to customers</li><li>Implement changes to streamline workflows and enhance efficiency</li>"},{"text":"What This Role Needs","content":"<li>At least 5 years working experience in related field</li><li>Strong analytical and problem-solving skills</li><li>Experience in process optimization and workflow management</li><li>Proficiency with automation tools and technology</li><li>Excellent communication and coordination abilities</li><li>Ability to prioritize tasks and manage time effectively</li><li>Knowledge of customer experience best practices</li><li>Familiarity with fintech industry standards and trends</li><li>Collaborative mindset to build relationships with stakeholders</li>"}],"text":"Business Operations Analyst (Trust and Safety) - GoPay - #10311","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><b style=\"font-size: 16px;\">Job Scope</b></div><div><span style=\"font-size: 16px;\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px;\">6 Months Challenge</b></div><div><span style=\"font-size: 16px;\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","descriptionBodyPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056","applyUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264950378,"description":"","descriptionPlain":"","id":"73e71b86-d53f-4841-92ec-4bd09a0ef479","lists":[{"text":"What You Will Do","content":"<li>explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across the Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs..</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Data Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479","applyUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716265340466,"description":"","descriptionPlain":"","id":"36d71dff-c9ac-44b8-b870-f74d941bd7d3","lists":[{"text":"What You Will Do","content":"<li>Design and implement complex data solutions, architecting data systems, and driving technical initiatives.</li><li>Optimize data infrastructure for performance, scalability, and reliability - working with large-scale data volumes &amp; distributed systems.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Provide technical guidance and support to ensure the successful delivery of data projects, including troubleshooting and resolving technical challenges.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>5+ years of experience in data engineering, software engineering, or a similar role.</li><li>Expertise in programming languages such as Python, Java, or Scala.</li><li>Advanced knowledge of SQL, database management systems, and data warehousing concepts.</li><li>Extensive experience with big data technologies and distributed systems.</li><li>Proven track record of designing and implementing complex data pipelines and ETL processes.</li><li>Deep understanding of cloud-based data technologies and best practices.</li><li>Leadership abilities to mentor junior team members and lead technical initiatives.</li><li>Strong problem-solving and troubleshooting skills.</li><li>Ability to communicate technical concepts effectively to both technical and non-technical stakeholders.</li>"}],"text":"Data Engineer Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3","applyUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3/apply"},{"additionalPlain":"About the Team\n\nThe Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience. \nAs a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience.&nbsp;</div><div>As a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1717749466111,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","description":"<div><span style=\"font-size: 10pt\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","id":"d93a7524-8ab9-4499-9f04-0876fcafa529","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain performance management dashboards and visualizations.&nbsp;</li><li>Provide regular analysis on operational performance metrics including transactions, conversion rate, lead quality, cost efficiency, retention, and KPI tracking to guide decision-making and devise proactive solutions.&nbsp;</li><li>Collaborate across teams to drive Operational Excellence (OPEX) and Continuous Improvement Process (CIP) initiatives, identifying growth opportunities for product, customer, driver, and optimization.&nbsp;</li><li>Support senior management with clear and concise presentations of complex data sets for informed decision-making.&nbsp;</li><li>Build, automate, and enhance reporting, data logging, and data pipelines for availability, integrity, accuracy, and reliability, ensuring security and compliance.&nbsp;</li><li>Assist in report compilation, issue investigation, and liaison with internal and external stakeholders for regulatory compliance.</li>"},{"text":"What You Will Need","content":"<li>Bachelors' Degree in Economics, Computer Science, Engineering, Mathematics or Statistics.&nbsp;</li><li>Minimum 5 years experience with 3+ years of relevant experience in analytics and product/process improvement.&nbsp;</li><li>Proficient in analyzing large datasets and translating quantitative findings into actionable insights.&nbsp;</li><li>Excellent understanding of analytics, computational modeling, business needs analysis, data visualization, and stakeholder management.&nbsp;</li><li>Resilience and initiative in a fast-paced, dynamic environment&nbsp;</li><li>Proficient in SQL; experience in BI tools such as Tableau, Metaforce, Python or Looker is a plus&nbsp;</li><li>Prior experience demonstrating strong stakeholder engagement and vendor management skills is a plus</li>"}],"text":"Data Operations Analyst","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529","applyUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Internship","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719909376581,"descriptionPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","id":"816f2d4c-5ff6-4e83-8697-9c25df599409","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li><b>Fresh Graduates </b>from computer science, mathematics, or statistics<b>&nbsp;</b>(Students on final semester are also preferred)</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Data Scientist Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409","applyUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409/apply"},{"additionalPlain":"Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.\n","additional":"<div><span style=\"font-size: 10pt\">Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718963848611,"descriptionPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","description":"<div><span style=\"font-size: 9pt\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","id":"5d07cd21-8826-4de7-9ad4-15909a0c5c37","lists":[{"text":"What you will do","content":"<li>Devise and implement tailored digital marketing strategies for GoRide, GoCar, GoSend, and GoShop</li><li>Analyze market trends to identify growth opportunities and refine strategies accordingly</li><li>Collaborate cross-functionally to ensure alignment with business goals</li><li>Monitor and evaluate campaign performance to drive optimization</li><li>Stay updated on industry trends and technologies to drive innovation</li><li>Manage relationships with external partners and agencies to support initiatives</li><li>Contribute to overarching marketing strategies and brainstorming sessions.</li><div><br></div>"},{"text":"What you will need","content":"<li>3+ years of digital marketing experience</li><li>Proficiency in digital marketing tools and platforms such as Google Adwords, Meta, TikTok Ads, Google Analytics &amp; Data Studio/Looker</li><li>Strong analytical, communication, and problem-solving skills</li><li>Bachelor's degree in Marketing, Communications, or related field</li><li>Fluency in English. </li><div><br></div>"}],"text":"Digital Marketing Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","descriptionBodyPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37","applyUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37/apply"},{"additionalPlain":"The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1722240835278,"descriptionPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","description":"<div><span style=\"font-size: 9pt\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","id":"eb38692a-8133-4cd2-a793-f5d75ee8841a","lists":[{"text":"What You Will Do","content":"<li>Accountable for leading the driver onboarding and support team, ensuring a quick and seamless experience for driver-partners at the GoHub</li><li>Management of day-to-day operations of the team, including communications and KPI performance management</li><li>Drive results through strong internal and external collaboration to improve the quality and efficiency of the team</li><li>Support &amp; drive operational requirements, to achieve and exceed team productivity and service level targets</li><li>Responsible for the design, deployment and maintenance of processes arising from new product launches and enhancement to existing process flows</li><li>Understand reporting needs and provide appropriate data analysis on performance metrics for stakeholders</li><li>Work with relevant stakeholders to identify and prioritize improvement initiatives and other cross-functional projects</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience as an operations manager in a contact center / frontline customer service operations</li><li>Experience in managing teams, motivating, coaching and inspiring team members to achieve excellent customer experience</li><li>Address conflicts and interpersonal issues within the team professionally and diplomatically</li><li>Ability to make informed decisions under pressure, considering both short-term and long-term implications</li><li>Keen eye for detailed process steps &amp; identification of gaps/opportunities</li><li>Strong stakeholder and project management capabilities</li><li>Efficiently manage time, resources, and priorities to ensure productivity and meet deadlines</li><li>Keep customer needs in mind when making decisions and managing operations</li><div><br></div>"}],"text":"Driver Care Lead, Hub Operations","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","descriptionBodyPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a","applyUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a/apply"},{"additionalPlain":"About the Team\n\nWe are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nAlong with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1714628452648,"descriptionPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px\">&nbsp;</span></div><div><span style=\"font-size: 16px\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","id":"dfe98505-36d8-4467-aa36-df8599ab69d8","lists":[{"text":"What You Will Do","content":"<li>Assess and manage team performance through staff meetings, one on ones, and quarterly assessments</li><li>Mentor your engineers to ensure their growth and engagement in the team, evaluate team workload and develop a staffing plan, and assign projects and balance workload to ensure continuous delivery and higher predictability</li><li>Serve as primary interface to staffing team, creating job descriptions, identifying sources for candidates, conducting interviews and shepherding candidates through the process</li><li>Lead a team of Software Engineers focused on improving velocity and impact across Gojek’s diverse project areas and platforms</li><li>Become a partner to Product Managers on deciding vision, strategy and OKRs</li><li>Provide technical expertise throughout the product life cycle including design, implementation, and delivery of scalable build/test/release infrastructure</li>"},{"text":"What You Will Need","content":"<li>Having at least 8 years of relevant software development experience preferably with experience in data products, also at least 2 years of leading and mentoring an engineering team to success</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, TDD and Test Engineering, and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate dependency risks</li><li>Ability to review the code and ensure code maintainability as part of new product enhancements.</li>"},{"text":"Bonus Points If","content":"<li>Understanding in data modeling for data warehouse, relational database, and non-relational database</li><li>Understanding in batch and stream data pipeline; Beam, Flink, Spark</li>"}],"text":"Engineering Manager - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px;\">&nbsp;</span></div><div><span style=\"font-size: 16px;\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8","applyUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8/apply"},{"additionalPlain":"About the Team\n\nThe Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721370013113,"descriptionPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","id":"178ba514-705f-4f0b-9e48-fe917c47a95b","lists":[{"text":"What You Will Do","content":"<li>Continuously monitor, review, maintain, and improve security controls that are used to secure GoTo enterprise IT systems and SaaS services;</li><li>Review and implement initiatives to improve the security posture of GoTo enterprise IT systems and SaaS services;</li><li>Perform security hardening on GoTo IT systems and SaaS services;</li><li>Support the remediation of relevant security issues relevant to GoTo corporate IT systems and SaaS services;</li><li>Provide answers and recommendations to security-related questions, queries, and requests related to GoTo enterprise IT systems and SaaS services;</li><li>Develop, review, and improve technical documentation and reports relevant to the security controls used by GoTo corporate IT systems and SaaS services.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, networking, and general security concepts (a bachelor's degree or higher is a plus).</li><li>At least 5 years of experience in cyber security, preferably with hands-on experience in implementing and maintaining the security of enterprise grade IT systems and SaaS services, e.g., Google Workspace, Microsoft 365, Slack, SAP, or Atlassian;</li><li>Proven hands-on experience in the configuration and troubleshooting of enterprise security solutions, e.g., EDR, MDM, DLP, Firewall, and/or SASE;</li><li>Proven hands-on experience in the management and security of enterprise collaboration tools such as Google Workspace, Microsoft 365, or Lark;</li><li>Coding and scripting skills especially for automation is highly desired;</li><li>Ability to develop clear and concise documentation and reports.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Enterprise Information Security Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","descriptionBodyPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b","applyUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b/apply"},{"additionalPlain":"About The Team\n\nCost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Cost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.</div>","categories":{"commitment":"Permanent","department":"FinTech - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718852731439,"descriptionPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","id":"60283bc5-9f60-400a-8289-bcbe332fbc09","lists":[{"text":"What You Will Do","content":"<li><b>Planning</b>: Work closely with the budget owner to prepare annual budget planning, re-forecast, rolling forecast on a periodic business cycle. Review budget activities completed by the budget owner with accurate baseline, information, and proper justification</li><li><b>Controlling</b>: Responsible for reviewing and approving each spending related to Opex and Capex according to the applicable Expense Management PolicyWork closely with the budget owner to ensure each spending request is based on business requirements, supported by budget availability, and budget transfer process (if required). Collaborate with the other stakeholders in building the right cost base e.g., Procurement, Budget owner, etc.</li><li><b>Monitoring</b>: Create and refine report in order to provide the right data and information to the CFO, FBP and Budget Owner to analyze the actual spends against the available budget on monthly basis with a pre-defined report including its associated drivers. Understand the variance including the explanation and/or justification from the Budget Owner whenever the spend exceeded the approved budget. Continue to work closely with the Budget Owner in supporting the identification of risks &amp; opportunities for cost-efficiency purposes. Highlight key financial issues and deliver the proposed solutions to the stakeholders, provide insightful financial analysis on a regular and ad-hoc basis such as but not limited to topline daily/weekly tracker, business unit performance review, and other financial ratios analysisIn certain circumstances, this candidate will work with Cost Management Head to support the entire products under GoTo Financial product or Function group.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's Degree in Accounting / Finance/ Business, or equivalent educational background</li><li>Minimum 5 years of working experience in Finance Business Partner / Cost Control areas</li><li>Able to build a financial model, proficiency in Microsoft Excel and Gsheet/Gdocs</li><li>Strong business, data-driven acumen, and ability to work with big database</li><li>Able to manage multiple stakeholders across various levels of seniority</li><li>Strong project management skills to manage complex projects; able to prioritize multiple internal and external stakeholders; and able to drive consensus</li><li>Strong team player; possesses team synergy skills with a high level of enthusiasm in collaborating with cross-teams</li><li>Able to work independently and high attention to detail with swift execution</li><li>Proficiency with Finance / Accounting tools (e.g. SAP and ERP) is a plus</li><li>Fluent in English (written and spoken)</li>"}],"text":"Financial Controller Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","descriptionBodyPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09","applyUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09/apply"},{"additionalPlain":"About the team \n\nThe Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. \n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. </div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721025492852,"descriptionPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","id":"a9daeacc-5dda-4735-ad7b-db35eb7593a6","lists":[{"text":"What you will do","content":"<li>Support Compliance and Regulatory Affairs matters in GoTo Financial Services operations, which includes but is not limited to business/product reporting and approval process with the regulators, compliance advisory assistance to business unit, as well as technical regulatory assessment</li><li>Provide Compliance advisory assistance for Financial Services operations, in both consumer and merchant-facing operation</li><li>Create and maintain the latest update of Financial Services regulations databases and provide/disseminate assessments on such regulations to the internal units in GoTo Financial</li><li>Provide assistance and support to the Head of Compliance and Senior Manager of Financial Services Compliance in any external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders</li><li>Give continuous support on the creation, standardization, and implementation of Financial Services Compliance, policies, terms &amp; conditions, internal working procedures, and standard operational guidelines</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law and Accounting. Having a master’s degree would be an advantage.</li><li>Possessing certifications in Risk Management/ IT Audit will be an advantage.</li><li>At least 4 years of mixed experience in the area of payment policy/ regulatory compliance.</li><li>Intermediate level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks, proactively choose the best solutions, and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including builds credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"FinServ Compliance Officer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6","applyUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6/apply"},{"additionalPlain":"The Fleet Team is a newly established team in Gojek. The mission of the team is to create strategic partnerships to increase GoCar supply in a sustainable way, which in turn will enhance customer reliability, and create a bigger market for ride-hailing in Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Fleet Team is a newly established team in Gojek. The mission of the team is to create strategic partnerships to increase GoCar supply in a sustainable way, which in turn will enhance customer reliability, and create a bigger market for ride-hailing in Indonesia.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1722249916751,"descriptionPlain":"As Fleet Account Manager, you will be responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).\n","description":"<div><span style=\"font-size: 10pt\">As Fleet Account Manager, you will be&nbsp;responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).</span></div>","id":"c48698b4-3bff-4e56-b250-cadf67700c6d","lists":[{"text":"What you will do","content":"<li>Obtain in-depth and robust understanding of both Gocar &amp; fleet partners business needs / issues, at the same time act as a trusted advisor for them to sustain and grow their business</li><li>Create pipeline and bring in new fleet partners into Gocar ecosystem</li><li>Find ways to leverage Gojek’s existing structures (eg. driver engagement) to exert influence over driver’s SH/AR/CR/location</li><li>Develop end-to-end joint business plans, monitor fleet partner’s performance versus target, assess competitive benchmarking and anticipate potential business challenges</li><li>To take responsibility for all services that Gojek delivers to each account, become the single point of contact from Gojek for engagement, project delivery &amp; troubleshooting efforts</li><li>To playbook these efforts and scale your knowledge and best practices to operations team</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 6 years work experience in relevant sectors, e.g. account management, management consulting, PMO in reputable&nbsp; organizations</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in Bahasa Indonesia (must-have) and English (nice-to-have)</li><li>Strong business acumen (have a basic understanding of P&amp;L/profit &amp; loss)</li><li>Ability to deliver results and close win-win deals / agreements</li><li>Able to articulate knowledge and insights into document that can be leveraged across the orgarnization</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Fleet Account Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Fleet Account Manager, you will be&nbsp;responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).</span></div>","descriptionBodyPlain":"As Fleet Account Manager, you will be responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d","applyUrl":"https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d/apply"},{"additionalPlain":"About the Team\n\nWorking with our team is an exciting and enriching experience, as we play a pivotal role in shaping the frontend ecosystem of the organization. As a cohesive unit, we focus on several key aspects, making our collaboration both productive and rewarding.\n\nOur team takes pride in developing and maintaining the central design system. This system ensures consistency and efficiency across all our web applications, resulting in a seamless and unified user experience. We are at the forefront of building and optimizing our web platform tooling. These tools enhance our productivity and code quality, allowing us to deliver exceptional frontend solutions efficiently. We actively contribute to internal product development. Our expertise in frontend engineering enables us to align with product visions and business objectives, ensuring the successful delivery of high-quality products that delight our users. By adhering to industry standards and conducting thorough code reviews, we ensure that our codebases are consistent, maintainable, and secure. This commitment to excellence translates into reliable and robust applications.\n\nWorking together, we foster an inclusive and supportive environment where every team member's ideas and perspectives are valued. Our dedication to mentorship and knowledge sharing ensures that we grow both as individuals and as a team. As a member of our team, you will have the opportunity to expand your skills, learn from experienced peers, and make a meaningful impact on the organization's frontend landscape. Collaboration, innovation, and a passion for frontend development define us. We welcome individuals who share our enthusiasm and dedication to join us on this journey of building exceptional web experiences and driving standardization across our organization.\n\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Working with our team is an exciting and enriching experience, as we play a pivotal role in shaping the frontend ecosystem of the organization. As a cohesive unit, we focus on several key aspects, making our collaboration both productive and rewarding.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team takes pride in developing and maintaining the central design system. This system ensures consistency and efficiency across all our web applications, resulting in a seamless and unified user experience. We are at the forefront of building and optimizing our web platform tooling. These tools enhance our productivity and code quality, allowing us to deliver exceptional frontend solutions efficiently. We actively contribute to internal product development. Our expertise in frontend engineering enables us to align with product visions and business objectives, ensuring the successful delivery of high-quality products that delight our users. By adhering to industry standards and conducting thorough code reviews, we ensure that our codebases are consistent, maintainable, and secure. This commitment to excellence translates into reliable and robust applications.</span></div><div><br></div><div><span style=\"font-size: 16px\">Working together, we foster an inclusive and supportive environment where every team member's ideas and perspectives are valued. Our dedication to mentorship and knowledge sharing ensures that we grow both as individuals and as a team. As a member of our team, you will have the opportunity to expand your skills, learn from experienced peers, and make a meaningful impact on the organization's frontend landscape. Collaboration, innovation, and a passion for frontend development define us. We welcome individuals who share our enthusiasm and dedication to join us on this journey of building exceptional web experiences and driving standardization across our organization.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1722247155831,"descriptionPlain":"About the Role\n\nAs a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups. \n\nIf working on deep & challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">If working on deep &amp; challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!</span></div><div><br></div>","id":"f7107250-7aa4-487c-8821-8948dfb0fbc3","lists":[{"text":"What You Will Do","content":"<li>Work with engineers and business stakeholders to understand the nature and background of the problems</li><li>Pair with fellow engineers to dissect the incoming problem statement and contribute to the solutioning</li><li>Craft reusable, reliable, accessible &amp; delightful UI components that work flawlessly across various web browsers &amp; devices</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Build and maintain various utilities focused on improving designer or developer productivity</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Ensure that the application and its components are robust by writing automated tests which covers all the critical flows in the application.</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript</li><li>Solid command over React JS with the flavor of TypeScript</li><li>Keen design and UX sense to analyze and understand the designs and wireframes</li><li>Good understanding of common web security threats and practices along with OWASP 10</li><li>Experience with <a href=\"http://node.js\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Frontend Engineer - Web Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">If working on deep &amp; challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups. \n\nIf working on deep & challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3","applyUrl":"https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705377654170,"descriptionPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","id":"a3543985-6d2c-45cf-84f7-312ec7efed36","lists":[{"text":"What Will You Do","content":"<li>Write and deploy code that's clear, concise, performant, tested, and easy to understand by other teams and engineers</li><li>Participate in design reviews and own feature development from end to end</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices</li><li>Deep dive and debug production issues across services and levels of the stack when needed</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently</li>"},{"text":"What Will You Need","content":"<li>5+ years experience building consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Proficiency with one or more programming languages like Java, Go, and Kotlin.</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, asynchronous programming, fault tolerance and monitoring, performance, feature flags</li><li>Understanding how mobile/web applications interact with back-end and other systems. Experience in building frontend UIs is a bonus</li><li>Good understanding of SQL/NoSQL databases</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, GCP</li><li>Excellent verbal and written communication skills</li><div><br></div>"}],"text":"Full Stack Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","descriptionBodyPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36","applyUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36/apply"},{"additionalPlain":"About the Team :\nWe are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \nThis includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team :</b></div><div><span style=\"font-size: 10pt\">We are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><span style=\"font-size: 10pt\">This includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><span style=\"font-size: 10pt\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718186798651,"descriptionPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","id":"6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","lists":[{"text":"What You Will Do","content":"<li>Build highly reliable frontend apps through appealing visual design with API integrations to support continuing increases in adoption of the products within Gojek</li><li>Work with engineers to understand the nature and background of the problems.</li><li>Work closely with all Data Platform teams to develop and rollout high quality products</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Contribute to improving team relatedness, and helps build a culture of camaraderie</li><li>Continuously refactor applications to ensure high-quality</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript.</li><li>Solid command over React JS with the flavor of TypeScript.</li><li>Keen design and UX sense to analyze and understand the designs and wireframes.</li><li>Good understanding of common web security threats and practices along with OWASP 10.</li><li>Experience with <a href=\"http://node.js\" class=\"postings-link\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server.</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management.</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Fullstack Engineer - Engineering Platforms","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt;\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt;\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","descriptionBodyPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","applyUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</div><div>We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</div><div>Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718006842841,"descriptionPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","id":"7d1c915f-ac53-4a2c-887a-41bbbda48a26","lists":[{"text":"What You Will Do","content":"<li>Execute design tasks such as layout composition, image editing, typography, and color correction</li><li>Assist in the development of design concepts for various marketing collateral, including digital advertisements, print and digital materials, and more</li><li>Support the Art Director to provide visual assets for video and key visuals productions</li><li>Think creatively to generate visuals that connect with target audiences</li>"},{"text":"What You Will Need","content":"<li>A bachelor’s degree, with 3 years of experience in a related field</li><li>Proficiency in design software such as Adobe Creative Suite (Photoshop, Illustrator, and Premier), with a basic understanding of design principles and techniques</li><li>A portfolio showcasing examples of design work</li><li>Strong attention to detail and a passion for visual storytelling, with the ability to create compelling designs that resonate with the target audience</li><li>A can-do attitude with a determination to see tasks through to completion</li><li>Enthusiasm for design and a proactive attitude, with a desire to contribute ideas, and solve problems creatively</li>"}],"text":"Graphic Designer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","descriptionBodyPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26","applyUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26/apply"},{"additionalPlain":"About The Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Growth Analyst role will be reporting directly to the Head of Consumer Acquisition & Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Growth Analyst role will be reporting directly to the Head of Consumer Acquisition &amp; Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Consumer Experience","allLocations":["Jakarta"]},"createdAt":1721795385137,"descriptionPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","description":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","id":"5f86f9c4-80bc-437f-b09c-b61fd85c27eb","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Drive actionable insights recommendation such as making funnel conversion analysis, cohort analysis, long-term trends, user segmentation, etc.</li><li>Identify the business need and generate analysis&nbsp;</li><li>Create and manage dashboards and data pipelines to monitor metrics to measure business performance</li><li>Working closely with the Business team and other data team (Data Engineer, Business Intelligence) to implement data solution</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 2 years of working experience in data analytics field</li><li>Proficiency in data analysis tools, SQL. Strong analytical skills to interpret complex data sets and extract actionable insights.</li><li>High proficient in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficient in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Data Management: Familiarity with data collection, storage, and management best practices.&nbsp;</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li>"}],"text":"Growth Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb","applyUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb/apply"},{"additionalPlain":"About the Team\n\nThe Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720079397618,"descriptionPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","id":"9bc8bd8a-cadc-4942-81c4-193773a294df","lists":[{"text":"What You Will Do","content":"<li>Design and own growth strategy of GoPay Later product; make data-driven business decisions on a regular&nbsp;</li><li>growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps, and actual customer insights</li><li>Test and validate solutions through a proper experimentation process</li><li>Liaise with other analytical chapters within the Financial Services Platform as well as across Gojek such as Data Science, Data Engineering, Data Governance, Risk Analytics, etc, to ensure that initiatives are aligned and data integrity standards are adhered to.</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 2 years of working experience in an analytical role (data analyst / BI/data science/statistician, etc)</li><li>Strong SQL skills with expertise in either Excel/Python/R</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps</li><li>Strong project management skills to manage projects; able to work together with relevant units, also can manage and prioritize multiple internal stakeholders</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team</li>"}],"text":"Growth Analyst - GoPay Later","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","descriptionBodyPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df","applyUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713765081862,"descriptionPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","description":"<div><span style=\"font-size: 10.5pt\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","id":"761415aa-89b7-4ffb-a19b-2b91ac4243b4","lists":[{"text":"What You Will Do","content":"<li>Lead the strategy and growth function for GoModal. You will be collaborating with the Marketing &amp; Product teams on a daily basis.</li><li>Maintain rigor in analytical excellence in terms of data analytics, A/B test design, and appropriate statistical tests across the product funnel from acquisition, adoption, retention to monetization.</li><li>Discover growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps and actual customer insights.</li><li>Analyze our complex and ever-growing data, present insights, and propose strategic options to management to drive business decisions.</li><li>Test and validate solutions through proper experimentation process.</li><li>Importantly, using data to identify growth opportunities and problem solve so as to achieve business goals with metrics such as conversion rates of WL to submit KYC, adoption rate &amp; GTV (disbursement)</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 4 years of working experience in a growth or product role (growth marketing, data analyst, BI, strategy, etc).</li><li>Strong project management skill to manage complex projects; also can manage and prioritize multiple internal and external stakeholders.</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps.</li><li>Experienced planning, designing, and executing experiments. Also comfortable working with frequentist statistics to analyze experiment results.</li><li>Strong data visualization and data storytelling skills.</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team.</li><li>Preferred but not required: Strong SQL skills with expertise in either Excel/Python/R&nbsp;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Growth Lead (Merchant Lending)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","descriptionBodyPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4","applyUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714985249008,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","id":"2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Introduce beneficial business changes through well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve the business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resourcesProactively improve the operation process in the team and act on how to drive a faster, more effective, and efficient execution process through third-party tools or in-house service</li>"},{"text":"What You Will Need ","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience&nbsp;</li><li>Data analytics capability, have a good knowledge of SQL and experimentation processes; High Proficiency in Python and R is a plus</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Planning & Operation - GoFood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","applyUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e/apply"},{"additionalPlain":"About the Team \n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717479647909,"descriptionPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","id":"1fad1d82-dc7b-4d5a-b0d0-eb4678350242","lists":[{"text":"What You Will Do","content":"<li>Lead and Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Work closely with the Product, Marketing, Sales, Research, and Intelligence teams to understand merchant pain points and define the solution as well as Data, Ads, and Operation teams in the development and implementation of initiatives and strategies</li><li>Prepare reports of key merchant metrics analysis as a basis of rationale and recommendations to upper management, including CxOs of Gojek and GoTo Group</li><li>Conduct competitive benchmarking and analysis with local and international counterparts</li><li>Introduce beneficial business changes through a well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience</li><li>Strong critical thinking, coordination, and stakeholder management skills to drive analysis and cross-collaboration independently</li><li>Data analytics capability have a good knowledge of SQL and experimentation process; High Proficiency in Python and R is a plus</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also being a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Strategy Manager - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","descriptionBodyPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242","applyUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719458638459,"descriptionPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","description":"<div><span style=\"font-size: 10pt\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","id":"b68a9eb5-f615-441a-b04c-2d2c6a9d4703","lists":[{"text":"What You Will Do","content":"<li>Perform development and review of Business Continuity Management Framework and its supporting policies;</li><li>Strategize, coordinate, and provide challenge and advisory in the implementation of Business Continuity Programs such as BCP, BCP testing, Crisis Management exercise, and ways of integrating Business Continuity concept and awareness in the operational of business and support functions;</li><li>Respond to audit and regulatory requirements on BCM;</li><li>Design and deliver BCM communications and clinic sessions;</li><li>Provide Business Continuity update report to Management</li><li>Facilitate and support the execution of the plans at the time of a crisis event.</li>"},{"text":"What You Will Need","content":"<li>Minimum bachelor’s degree in relevant discipline from a reputable university</li><li>Minimum 8 years of Business Continuity Management experience in prominent consulting firms and/or multinational companies</li><li>Growth mindset, analytical, assertive and good interpersonal skill</li><li>Relevant BCM certifications&nbsp;</li><li>Good competency in English, verbal and written.</li>"}],"text":"Head of Business Continuity Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","descriptionBodyPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703","applyUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703/apply"},{"additionalPlain":"Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717651947726,"descriptionPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><span style=\"font-size: 16px\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"c838dc08-24e8-417c-9d70-a617bc58e200","lists":[{"text":"Responsibilities","content":"<li>Gojek is looking for an experienced technologist with a passion &amp; understanding of technology to lead its transportation product. Transport is one of the flagship products in GOJEK superapp. It is launched in Indonesia, Singapore and Vietnam.</li><div><br></div><li>As Head of Engineering of Transport, you will partner with GOJEK VP, Senior VP of technology, Transport Head of Business, Group Product Manager and other business stakeholders in the company to formulate a business strategy for Transport. You will work closely with PMs and Tech Leads in Transport to realize this strategy to make GOJEK a dominant player in markets.</li><div><br></div><li>Strategic thinking and strong business acumen along with deep technical expertise are essential in this role. We expect you to be well-versed in current technological trends and familiar with a variety of business concepts. If you are also an excellent communicator and public speaker, we’d like to meet you.</li><div><br></div><div>What you will do</div><div><br></div><li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Setup growth paths for the team and engage them in processes and practices that shall help scale engineering</li><li>Collaborate with cross functional teams and stakeholders (Business, Product, Data, UX, Platform, Devops etc.) to unlock the next phase of business growth.</li><li>Provide technology leadership to the team and foster engineering excellence.</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"Experience and Skills","content":"<li>Should have at least 9 years of hands-on experience in designing, developing, testing and deploying applications at scale.</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus.</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation.</li><li>Experience as people manager and passionate towards building and growing a high functioning team.&nbsp;</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions.</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities.</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Head of Engineering - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px;\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px;\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px;\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px;\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200","applyUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200/apply"},{"additionalPlain":"About The Team\nYou will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">You will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718871657577,"descriptionPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","id":"6dc20c4e-4d40-4f57-a138-4776013e454e","lists":[{"text":"What You Will Do","content":"<li>Oversee CS, Telesales, KYC, collection and FI team and Ops projects for our BNPL and cashloan product.&nbsp;</li><li>Develop &amp; Optimize Processes - Scale new and existing processes to allow the business to efficiently operate in Indonesia</li><li>Analytics - Analysis and tracking of onboarding, merchant experience and technical issues, risk management etc</li><li>Strategy - Choose which projects to prioritize, and set a timeline to reach goals quickly</li><li>Tool Improvements - Proactively search for new tools or ways which could improve a seamless support and setup experience, for both, merchant and buyer</li><li>Be fast, resourceful, and take initiative - Take ownership of regional commerce operations and do everything you can to support and enhance the quality of our services</li>"},{"text":"What This Role Needs","content":"<li>Min. 7 years experience in tech startup/fintech industry</li><li>Experience in operations strategy, sales strategy and product management is a big plus</li><li>Proven success in dynamic and complex environments, with a proven ability to rally teams and influence at all levels</li><li>Deep analytical skills, with high capacity to think strategically about complex issues, evaluate alternatives, and make compelling recommendations based on proven business case analysis</li><li>Outstanding communication skills, both verbal and written</li><li>Ability to lead complex and strategic initiatives and communicate effectively with technical teams</li><li>Ability to collaborate with various departments by utilizing superior relationship-building skills, interpersonal skills, and influence</li>"}],"text":"Head of Operation - Consumer Lending - #10162","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","descriptionBodyPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e","applyUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705905810213,"descriptionPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","description":"<div><b><span style=\"font-size: 18px\">About The Role</span></b></div><div><span style=\"font-size: 16px\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","id":"70493d8a-7d7f-4660-b1ed-c792d0d765be","lists":[{"text":"What You Will Do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What This Role Needs","content":"<li>At least 15 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Experienced in managing a huge team size</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closingExcellent in contract and commercial negotiation process</li><li>Experience in payment industry is a plus</li>"}],"text":"Head of Sales - Midtrans - #9618","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 18px;\">About The Role</span></b></div><div><span style=\"font-size: 16px;\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px;\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","descriptionBodyPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be","applyUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be/apply"},{"additionalPlain":"About The Team\nAs Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.\n\nOne of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing & executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.\n\nWe are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 14px\">As Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.</span></div><div><br></div><div><span style=\"font-size: 14px\">One of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing &amp; executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.</span></div><div><br></div><div><span style=\"font-size: 14px\">We are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Strategy","allLocations":["Jakarta"]},"createdAt":1708937527995,"descriptionPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","id":"7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","lists":[{"text":"What You Will Do","content":"<li>Design the overall end-to-end sales strategy which includes go-to-market (GTM) strategy and implied sales motions / incentives system</li><li>Define OKR &amp; building blocks for the entirety of nationwide sales team (Enterprise &amp; Small Medium Business teams) to ensure that company objectives are met - working closely with the product teams (including but not limited to GoFood, GoMart, GoCorp and GoPay)</li><li>Set sales targets in areas like product mix, sales volume, and market shares</li><li>Track OKR &amp; performance of the overall greater sales team (Enterprise, SMB Managed &amp; SMB Unmanaged teams) across all products</li><li>Oversee the execution of sales motions / building blocks: periodic review with working and/or leadership team, provide guidance to the overall sales strategy &amp; other relevant stakeholders</li><li>Establish a regular &amp; methodical planning rhythm to ensure that both sales team structure &amp; compensation plan are aligned to support reaching company targets. This would include merchant segmentation, sales structure review, sales earning optimization exercises, account mapping, territory planning; working together with the Head of Enterprise Sales and Head of SMB Sales</li><li>Become the bridge between Sales HQ &amp; on-the-ground merchant-facing teams to ensure seamless &amp; effective execution</li>"},{"text":"What This Role Needs","content":"<li>At least 10 years of relevant work experience in strategy, preferably within mid-to-senior management level from multinational company</li><li>Have strong analytical thinking and problem solving skills using various tools and methods</li><li>Comfortable working under pressure in a fast-paced and ambiguous environment</li><li>Ability to prioritize &amp; multitask across different initiatives (balancing breadth vs in-depth)</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Have great presentation skills - esp. the ability to present to senior management &amp; leadership</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>Fluent in Bahasa Indonesia &amp; English</li>"}],"text":"Head of Sales Strategy - #10056","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","descriptionBodyPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","applyUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721030934590,"descriptionPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","description":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","id":"9c0a73a5-09ce-4b06-8527-9415ef3d393c","lists":[{"text":"What You Will Do","content":"<li>Lead a team of IT Auditors in planning, preparation, coordination, and execution of audits to evaluate the adequacy and effectiveness of technology infrastructure, application, and process controls.</li><li>Provide clear, concise, and organized documentation of the audit processes and findings.</li><li>Identify and evaluate complex technology and business risks, implications, and related opportunities for improvements of internal controls.</li><li>Manage audit projects effectively – resource allocation, deliver on commitment, time management and quality reviews.</li><li>Serve as the Audit Committee Secretariat responsible for coordination of materials across the governance teams for periodic AC meetings.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Must have a minimum of 8-10 years of experience in technology audits, with at least 5 years in public accounting / advisory firms.&nbsp;&nbsp;</li><li>Must have strong practical experience in testing of GITC, application controls, ISO 27K, cybersecurity risk assessment, and ERP’s.&nbsp;</li><li>Must possess CISA certification at a minimum - additional certification in cyber, risk and technology governance preferred.&nbsp;</li><li>Knowledge and experience with OJK and Bank Indonesia (BI) technology audit requirements preferred.&nbsp;&nbsp;</li><li>Experienced with coaching and developing junior team members, strong confidence to interact with various stakeholders, excellent project management and organizational capabilities, ability to complete tasks and audit projects within tight deadlines.</li><li>Strong communication in English (verbally and in writing) and PowerPoint preparation skills.&nbsp;</li><li>Highly self-motivated, inquisitive (with a keen interest in learning new processes and technologies) and strive to continuously develop technically and professionally.</li>"}],"text":"Internal Audit Senior Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","descriptionBodyPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","hostedUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c","applyUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c/apply"},{"additionalPlain":"Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Corporate Affairs","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1720685009263,"descriptionPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","description":"<div><span style=\"font-size: 11pt\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","id":"fc5f2c90-038e-4c53-9971-2ae72f680c03","lists":[{"text":"What you will do","content":"<li>Gojek Singapore communications:</li><div>Serve as the overall PR point of contact and develop communications strategies for the Singapore market, collaborating with the Gojek Singapore leadership team.</div><div>Develop and execute PR plans for Singapore-related announcements, handling all external-facing communications and materials.</div><div>Engage with Singapore media, manage media queries, and manage crisis and issues across media <a href=\"http://channels.Proactively\" class=\"postings-link\">ch</a>annels</div><div>Proactively seek thought leadership opportunities and lead OKR reporting for PR-related <a href=\"http://metrics.GoTo\" class=\"postings-link\">me</a>trics</div><div><br></div><li>GoTo Group communications support:</li><div>Support Group-level announcements and the development of associated English language communication materials</div><div>Maintain relationships with key international media contacts and handle media queries</div><div>Support issues management teams.</div><div>Develop thought leadership content, manage media opportunities and awards, and oversee a number of owned channels.</div><div><br></div>"},{"text":"What you will need","content":"<li>Excellent writing skills - proficiency with Chinese language media in Singapore is a bonus</li><li>Proven ability to build and maintain relationships with media contacts</li><li>Experience in pitching stories and managing media inquiries.</li><li>A cool head in a crisis</li><li>Meticulous approach to reviewing materials and ensuring accuracy</li><li>Ability to manage multiple projects without compromising quality.</li><li>Flexibility to manage unexpected challenges and opportunities</li><li>Enthusiasm for travel (regular travel to indonesia will be required) </li><div><br></div>"}],"text":"International & Singapore Communications Manager","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 11pt;\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt;\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","descriptionBodyPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03","applyUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03/apply"},{"additionalPlain":"About the Team\n\nThe IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721378203517,"descriptionPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","id":"4cb00240-117e-4ace-a959-fc567e447d5f","lists":[{"text":"What You Will Do","content":"<li>Manage multiple complex IT Finance initiatives</li><li>Ensure initiative deliveries are on time and adhere to IT Project Life-Cycle standards</li><li>Ensure information is delivered to the business through the correct channels, ensuring compliance with all controls and security requirements</li><li>Manage multiple internal stakeholders across countries and business units</li><li>Provide regular status updates to GoTo leaders and stakeholders</li>"},{"text":"What You Will Need","content":"<li>8+ years of work experience in IT project/program management in Finance Domain</li><li>Strong track record of leading successful IT projects/programs from start to finish&nbsp;</li><li>Ability to multi-task and effectively manage several projects in parallel</li><li>Ability to influence large, cross-functional teams</li><li>Strong interpersonal, facilitation, and leadership skills</li><li>Experience in managing Corporate Finance, Enterprise Data, and Enterprise business processes is highly desirable</li><li>Drive adherence to SDLC processes, drive to implement new processes and procedures applying industry knowledge and experience to cut costs, gain efficiencies, minimize risks, and reduce time to deploy, with attention towards automation and continuous improvement; make recommendations for process improvements; track and document all process improvements;&nbsp;</li><li>Good communication skills in English both oral and written</li>"}],"text":"IT Finance Project Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","descriptionBodyPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f","applyUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f/apply"},{"additionalPlain":"About the Team\n\nJoining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Joining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713930486899,"descriptionPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","id":"36caef5f-7a1c-4326-80b4-8c146060ac70","lists":[{"text":"What You Will Do","content":"<li>Develop and maintaining IT policies, standards and procedures according to applicable internal and external requirements, including the applicable regulations in Indonesia an other countries where GTF operate;</li><li>Develop and maintain compliance, governance and risk-related IT and business process flow;</li><li>Coordinating with compliance team to ensure that every initiative, development and collaboration are comply with the standards and regulations (internal and external);</li><li>Conduct routine evaluation of policies and procedures implementation and ensure best practice risk mitigation and assessment functions are maintained to comply with the company's strategy;</li><li>Coordinate with related IT work units to follow up on data requests and internal audit findings, external audits and regulators;</li><li>Develop the process and conduct the activities to safekeep or archive of every IT development document in a regular basis;</li><li>Implementing a good governance organization using the ISO27001, ISO 27701, PCI DSS framework and other relevant Technology &amp; Security best practices;</li><li>Develop and implement the RBAC and least privilege of access management in the GTF technology stack</li><li>Act as a Subject Matter Expert to the stakeholders and provide relevant &amp; applicable consultation for addressing the IT GRC requirement in lending product &amp; services.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years experiences as Information Security, IT Governance, Risk and Compliance (IT GRC) or IT Auditors;</li><li>Demonstrate excellent communication and writing skills and proficient with English written and spoken</li><li>Experienced in developing and maintaining IT and/or information security policies and procedures;</li><li>Excellent knowledge in developing risk management and IT framework, BIA, BCP and BCM Framework</li><li>Experienced in report document development and delivery;</li><li>Experienced in dealing with regulatory audit to represent the organization IT GRC operations;</li><li>Having good knowledge with local and regional payment &amp;&nbsp; lending regulatory requirements and how they impact IT policies (having experience is preferred);</li><li>Having excellent experience with ISO 27001, ITIL. COBIT, and PCI-DSS standards;</li><li>One or more of the following or equivalent certifications preferred: CISA, CRISC, ITIL, COBIT is preferred</li>"}],"text":"IT GRC Senior Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","descriptionBodyPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70","applyUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70/apply"},{"additionalPlain":"About The Team\n\nGoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.\n\nOur achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.\n\nAs a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design & Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.</div><div><br></div><div>Our achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.</div><div><br></div><div>As a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design &amp; Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720592684329,"descriptionPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","description":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","id":"da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of your Writer lead, and follow the predefined process that has been set by the team</li><li>Understand the product briefs and present ideas/solutions to the team under the supervision of your writer lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Proactively attend design reviews to gather feedback and provide critiques if needed</li><li>Proactively seek knowledge about UX</li><li>Participate in the end-to-end design process with peer researchers, designers, business, product and engineering teams. You will also get to engage with marketing and customer care unit to ensure the content is cohesive</li><li>Own your assigned streams and organize assigned tasks; which includes communicating updates and progress via the provided forums and channels. Be flexible to collaborate with other streams when needed</li>"},{"text":"What You Will Need","content":"<li>At least 1 year of experience in product writing for digital products or services</li><li>Strong understanding of writing fundamentals, critical/creative/structured thinking skills, grammar in both English &amp; Indonesian, and a familiarity of product design/ design thinking frameworks in order to further develop your writing output</li><li>Excellent communication and grammar skills in both English and Indonesian, both verbal and written, to effectively collaborate with stakeholders of varying seniority and backgrounds</li><li>A user-centric mindset in order to see things from their perspective, understand their concerns and feedback, and incorporate these insights into the work you produce</li><li>A drive to always find the root cause of an issue and validate your design - either through quantitative or qualitative research</li><li>A structured portfolio of written work that shows your ability and problem solving skills, a bonus if it demonstrates business impact and results</li><li>Ability to handle multiple tasks and prioritize work simultaneously</li><li>Demonstrate a detailed-oriented thought process with excellent documentation discipline</li>"}],"text":"Junior UX Writer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","descriptionBodyPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","applyUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d/apply"},{"additionalPlain":"About the Team\n\nTransport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.\n\nDespite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Transport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.</div><div><br></div><div>Despite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. </div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899257808,"descriptionPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","id":"f1d481f6-4e2d-401b-b310-fca641ab29d4","lists":[{"text":"What you'll do","content":"<li>Lead, mentor and recruit a team of highly talented and motivated engineers</li><li>Build and deploy features iteratively in production</li><li>Work cross-functionally with product, engineering and design teams across Gojek</li><li>Collaborate with internal teams to build and iterate on features</li><li>Build delightful user-facing experiences with smooth performance</li><li>Mentor and provide feedback to colleagues, participate in organisation building</li><li>Participate in research trips to better understand aspirations and pain points of our customers</li>"},{"text":"What you'll need","content":"<li>Should atleast have 6 years of relevant experience</li><li>Deep understanding of the iOS frameworks like UIKit, Foundation, etc.</li><li>Experience developing iOS apps in Swift</li><li>Attention to detail, particularly around software engineering fundamentals, testing methodologies, and quality</li><li>A strong customer focus</li>"}],"text":"Lead - iOS (Transport)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4","applyUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720610213311,"descriptionPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","description":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","id":"c9452ba2-cbb3-4ea5-83f7-79e765a67e58","lists":[{"text":"What You Will Do","content":"<li>As the Lead Auditor, you will support the design of risk-based audit plan influenced by regulatory compliance requirements, business needs and inputs from the governance teams (ERM, Ethics and Regulatory Compliance). You will deliver the audit as planned, discussion of issues with business and Group Audit, write up of report, advise and monitor on remediation progress. </li><div><br></div><div>Expectations of the role include: </div><div><br></div><li>Ability to deliver audit engagements independently and efficiently</li><li>Effective verbal and written communication (in Bahasa and English) of audit findings, remediation and reports to management.</li><li>Active participation and contribution to team discussion, audit planning, and stakeholder engagements.· &nbsp; </li><li>Ability to analyze operational process, regulatory issues and root cause.</li><li>Strong focus on quality deliverables such as audit report, work paper write ups, and presentation.</li>"},{"text":"What You Will Need","content":"<li>Mandatory: Minimum 8 years of audit experience obtained from public accounting and financial services internal audit roles.</li><li>Mandatory:&nbsp; Understanding and experience complying / auditing of relevant OJK regulations for multi-finance institutions.</li><li>Relevant certification in audit and risk preferred.</li><li>Highly motivated, demonstrated leadership attributes, meticulous attention to detail and problem solving</li><li>Effective communication in both Bahasa and English (verbal and written).</li><li>Ability to use data analysis tools (like ACL, MS Excel, Tableau, etc.).</li>"}],"text":"Lead Internal Auditor","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","descriptionBodyPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58","applyUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58/apply"},{"additionalPlain":"About The Team\nOur data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n","additional":"<div><b>About The Team</b></div><div>Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1719896801671,"descriptionPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","id":"4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","lists":[{"text":"What You Will Do","content":"<li>Manage data science infrastructure to streamline model development and deployment</li><li>Define and build scalable data pipelines that enables data scientists to build better models</li><li>Implement cutting edge big data frameworks to support batch and real-time jobs</li><li>Identify possible bottlenecks in the system and perform optimization</li><li>Build dashboards, models and deliver insights to support business analytics</li><li>Monitor and provide support to our infrastructure and production models</li><li>Mentoring team members through code review and knowledge sharing</li>"},{"text":"What You Will Need","content":"<li>At least 7 years of hands-on experience at large scales in data science / software engineering</li><li>Ability to write clean and structured SQL, Python and Shell programs</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Kubenetes, Docker, Infrastructure as Code, RDBMS and NoSQL Databases</li><li>Good understanding of machine learning techniques and algorithms</li><li>Good experience in serving real-time, production-level machine learning models</li><li>Management experience is preferred</li><li>Excellent communication skills</li>"}],"text":"Lead MLOps Engineer","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","descriptionBodyPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","applyUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0/apply"},{"additionalPlain":"About the Team\n\nThe GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.</div>","categories":{"commitment":"Permanent","department":"ODS - Transport & Mobility","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718255937171,"descriptionPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","id":"8bf17375-6318-400f-8216-4a132071777a","lists":[{"text":"What You Will Do","content":"<li>Roadmapping → Establish strategic objectives, roadmap and timelines to guide the development and enhancement of the GoCorp platform</li><li>Focus on optimizing the client experience, ensuring the platform meets and exceeds user needs and expectations. Execute with precision make sure products and features are launched in timely manner</li><li>Seek product ideas and feedback based on both quantitative and qualitative date, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that one size doesn’t fit all and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Work closely with business, sales, and marketing teams to align product strategies and objectives. Ensuring the all teams runs with the same drumbeat&nbsp;</li><li>Ensure seamless coordination with other product teams connected to the GoCorp platform to maintain a cohesive product ecosystem</li>"},{"text":"What You Will Need","content":"<li>Proven experience if min 5-6 years in product management, preferably within a tech or platform-based company and B2B product</li><li>Strong strategic thinking and planning skills with the ability to set and achieve the mid term and long-term objectives</li><li>Data oriented – demonstrated an ability to balance between quantitative and qualitative data to optimize client experience.</li><li>Exceptional problem-solving skills with a proactive approach to overcoming challenges</li><li>Excellent collaboration skills with experience working across multiple departments</li><li>Proficiency in managing the entire product lifecycle, from concept to launch and beyond</li><li>Strong communication skills to articulate product vision and objectives effectively to diverse stakeholders</li><li>Solid understanding of the technical aspects of platform development and integration.</li><li>Fluent in written and verbal english</li>"}],"text":"Lead Product Manager, GoCorp","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a","applyUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1716776042348,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"4a126665-42d6-4a36-82a5-089dca789f41","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Nurturing &amp; mentoring 5-7 engineers members</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize their ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 7-8+ years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Leadership experience in leading a distributed team of software engineers</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>Working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, xgboost, Keras</li><li>Prior experience with cloud provider (GCP is a plus)</li>"}],"text":"Lead Software Engineer - Data Science Platform","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41","applyUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719911495540,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","id":"a593bf17-baf2-479e-8154-c69d6a7d4f09","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost-effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems </li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure </li><li>Enhance code quality and product performance through continuous improvement and innovation </li><li>Collaborate and communicate effectively with teams across multiple geographies </li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves </li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices </li>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Erlang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with messaging protocol such MQTT &amp; prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Engineering Platforms","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09","applyUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. \n\nAt the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. </div><div><br></div><div>At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</div><div><br></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1711535878605,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","id":"3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems</li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure</li><li>Enhance code quality and product performance through continuous improvement and innovation</li><li>Collaborate and communicate effectively with teams across multiple geographies</li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves</li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in working with end to end Observability stack. Hands on experience in building and managing the telemetry pipeline at large scale</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with Grafana stack, Cortex, SLI/SLO platforms is a plus</li><li>Prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Observability","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","applyUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a/apply"},{"additionalPlain":"About the Team :\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</div><div><br></div><div>We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899083492,"descriptionPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","id":"9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences with minimal guidance for one of the world's fastest growing companies in travel</li><li>Understand, design and build to optimize in terms of resources used on the devices as well as simplify to meet the challenges of our always on-the-go users</li><li>Translate business requirements into scalable and extensible design</li><li>Partner with the product management team to define and execute the feature roadmap.Be responsible for defining and executing for complex, long term initiatives and help the team objectively lay out the roadmap and execute against smaller milestones</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Coordinate with cross functional teams (Backend, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence. Be the flag bearer for setting long term execution strategies and bring about the culture of operational excellence in the team</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in Android application development and product delivery</li><li>Predictability and balance of product delivery speed and quality</li><li>In depth knowledge of Android Apps architecture and implementation including proficiency in Kotlin, Architectural Components, Git, and Gradle</li><li>Understanding of TDD, Dependency Injection principles, Mobile Performance Tuning (Load time, Crash/ANR/Memory Leak tracking, Network optimisations)</li><li>Strong problem solving and analytical skills and a proven track record of being able to respond effectively to customer situations</li><li>A command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>A track record and passion for improving the code structure and architecture to improve testability and maintainability</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><div><br></div>"}],"text":"Lead Software Engineer - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","applyUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1704273923584,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","id":"2d3aae20-ff7e-4afb-8164-a351661c1680","lists":[{"text":"What You Will Do ","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest-growing company in the transportation industry&nbsp;</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Partner with the product management team to define and execute the feature roadmapCoordinate with cross-functional teams (Mobile, DevOps, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building the next generation of Gojek services</li>"},{"text":"What You Will Need ","content":"<li>Should have at least 6 years of hands-on experience in designing, developing, testing and deploying applications on Java or Go for large scale applications</li><li>Proficient in System Design, OOP, SQL, Linux/Unix, and Design Patterns. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities, through self-discovery or by vouching for exploratory tasks</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Lead Software Engineer (IC) - Go-Food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680","applyUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680/apply"},{"additionalPlain":"About The Team\n\nWe are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success\n\nWe're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>We are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success</div><div><br></div><div>We're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.</div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1721801286779,"descriptionPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","id":"ad8bd932-3494-4181-bd93-282665dce81d","lists":[{"text":"What You Will Do","content":"<li>Training Product Development: Develop and maintain detailed training materials, including manuals, user guides, and online resources, tailored to various audience levels. Collaborate with product managers, engineers, and other stakeholders to stay updated on product features and enhancements</li><li>Facilitation and Delivery: Conduct training sessions, both in-person and virtually, mainly for internal teams. Utilize a variety of instructional techniques and formats, such as role-playing, simulations, and interactive workshops</li><li>Assessment and Evaluation: Create and implement assessment tools to measure training effectiveness and knowledge retention. Gather feedback from trainees and use it to improve future training sessions</li><li>Support and Collaboration: Provide ongoing support and consultation to trainees post-training. Work closely with sales teams and internal stakeholders to address any training-related issues and ensure customer satisfaction to achieve business goals</li><li>Continuous Improvement: Stay current with the latest product developments and industry trends. Incorporate new training methodologies and technologies to enhance the learning experience.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or higher; majoring in Business, Economics, or relevant fields</li><li> 2 or 3 years of experience in a product training or related role within the tech industry. Has proven experience in developing and delivering training programs</li><li>Excellent presentation and communication skills</li><li>High attention to detail, has ability to explain complex technical concepts in a clear and accessible manner</li><li>Strong organizational and project management skills</li><li>Ability to adapt training methods to different learning styles and audiences</li><li>Ability to drive changes successfully and to keep people motivated in a highly changing environment&nbsp;</li><li>Proactive, ability to work in a team, and a strong can do attitude.</li>"}],"text":"Learning & Development Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d","applyUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713944910535,"descriptionPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","id":"cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Proactively establish and strengthen relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia.</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals.</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors.</li><li>Project Leadership: Lead multiple projects in partnership with government institutions, focusing on Tech and the Digital Economy.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances.</li><li>Project Management: Oversee public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred.</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government.</li><li>Established network among government stakeholders with a proven impact on policy decisions.</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Manager of Food & Groceries Regulatory","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","applyUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719989851823,"descriptionPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","description":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","id":"ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","lists":[{"text":"What You Will Do","content":"<li>Maintain MI’s automation backend availability on Google Cloud Project&nbsp;</li><li>Continuously developing data pipeline architecture to ensure excellent performance&nbsp;</li><li>Do complex data analysis which are related to the Market Intelligence topics</li><li>Continuous knowledge update on latest tech capability to enhance the Market Intelligence deliverable in terms of depth, speed and variety of sources of references</li><li>Build and maintain a playbook for Market Intelligence data engineering projects</li>"},{"text":"What You Will Need","content":"<li>At least 2 years in <b>Data Engineer </b>roles</li><li>Talks in Python &amp; Linux</li><li>Exposure to data modelling would be preferred</li><li>Loves to experiment on the latest tech trends</li><li>Passionate in problem-solving and Root Cause Analysis (RCA)</li>"}],"text":"Market Intelligence (Data Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","applyUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4/apply"},{"additionalPlain":"Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.\n\nAs a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. \n","additional":"<div><span style=\"font-size: 9pt\">Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.</span></div><div><br></div><div><span style=\"font-size: 9pt\">As a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. </span></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720579532578,"descriptionPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","description":"<div><span style=\"font-size: 9pt\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","id":"967cfe0a-0243-4a2d-8813-038c355e43c3","lists":[{"text":"What you will do","content":"<li>Manage the marketing budget and ensure efficient allocation as well as prepare the report and regularly present it to senior management</li><li>Lead marketing metrics development, monitoring, and performance analysis periodically, as well as identify areas for <a href=\"http://improvement.Stay\">improvement.</a></li><li><a href=\"http://improvement.Stay\">Stay</a> updated on industry trends and the competitive landscape to inform strategic decision</li><li>Lead marketing campaigns development, monitoring, and evaluation incl. creative &amp; media strategy development &amp; execution with relevant stakeholders</li><li>Actively collaborate across functions &amp; streams especially product and strategy &amp; planning team in growing Transport business.</li><div><br></div>"},{"text":"What you will need","content":"<li>Bachelor's degree from a reputable university or equivalent practical experience</li><li>Min 4 years of experience working in a brand or product marketing field in FMCG, technology, telecommunication, or start-up</li><li>Excellent written &amp; verbal communication abilities at the business level with strong presentation skills to represent the Marketing team in functional meetings</li><li>Ability to work in a fast-paced, deadline-driven, and VUCA (volatile, uncertain, complex, and ambiguous) work environment</li><li>Strong capacity planning and reporting abilities; strong commercial sense and logical thinking skills to think outside the box as well as an understanding of budgeting, financial planning, and marketing <a href=\"http://metrics.Strong\">metrics.</a></li><li><a href=\"http://metrics.Strong\">Strong</a> analytical and quantitative skills; ability to use hard data and metrics to back up assumptions, and recommendations, and drive actions.&nbsp;</li><li>Familiarity with data analysis tools and software (SQL, Tableau, and Google Analytics)</li><div><br></div>"}],"text":"Marketing Planning Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","descriptionBodyPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3","applyUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3/apply"},{"additionalPlain":"About The Team\n\nOur Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media. \n\nAs a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media.&nbsp;</div><div><br></div><div>As a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!</div>","categories":{"commitment":"Internship","department":"HoldCo - Corporate Affairs","location":"Jakarta","team":"Media Intelligence","allLocations":["Jakarta"]},"createdAt":1719818000669,"descriptionPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","description":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","id":"a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","lists":[{"text":"What Will You Do","content":"<li>Monitor corporate news and other related information across channels (print, online, and social media).</li><li>Gather and analyze data from media monitoring to gain insights into public perception of the company and its performance.</li><li>Extract data and present interesting information from findings.</li><li>Identify trends and issues relevant to the company’s needs.</li><li>Collaborate to provide data-driven insights for other teams</li>"},{"text":"What Will You Need","content":"<li>Undergraduate students, preferably from Economics, Business, Computer Science, Marketing, Public Relations or Literature.</li><li>High proficiency in English and Bahasa Indonesia, both written and verbal.</li><li>A critical thinker, observant, and detail-oriented with vast knowledge of current issues and trends.</li><li>High willingness to learn.</li><li>Comfortable handling large data sets.</li><li>Knowledge in Ms Excel.</li><li>A collaborative team member as well as an independent self-starter.</li>"}],"text":"Media Intelligence Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","descriptionBodyPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","applyUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb/apply"},{"additionalPlain":"About The Team\n\nThe management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.\n\nThe AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.</div><div><br></div><div>The AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.</div>","categories":{"commitment":"Permanent","department":"FinTech - AML/CFT","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719311112001,"descriptionPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","description":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","id":"f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","lists":[{"text":"What You Will Do","content":"<li>As an official directly appointed by the relevant Director and responsible for the implementation of AML CFT in the company.</li><li>A pointed person for any Regulatory Compliance matters/projects as well as internal or external auditors in compliance reviews.</li><li>As an industry expert, keep track of the latest developments around regulations and find smart solutions to mitigate ML/TF risks</li><li>Remain knowledgeable of new or changing regulations, regulatory expectations, market conditions, and industry best practices and find smart solutions to mitigate ML/TF risks</li><li>Ensure Subject Matter Experts participate in all activities where expertise is required, including but not limited to, risk assessments, policy writing, training development, advice to the business, monitoring activities, and reporting</li><li>Provide senior management with actionable advice on how to effectively manage AML/CFT-related risks</li><li>Ensure all regulatory reporting requirements related to AML/CFT themes are met</li><li>Ensure implementation AML CFT regular trainings as well to Business Unit and Support Function and to liaise with the Learning &amp; Development PAC;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years in this role in the AML/CFT</li><li>You have extensive knowledge of the payments and or the banking/finance industry</li><li>A thorough understanding of AML/CFT laws and regulations incl. risks, controls, industry best practices and regulatory requirements</li><li>An excellent and direct communicator who talks straight without being rude</li><li>You have the ability to clearly explain AML CFT compliance and related risks, develop sound mitigation strategies, and find workable solutions&nbsp;</li><li>You have extensive experience representing and leading meetings with regulatory agencies, examiners and auditors</li><li>You have the ability to structure and prioritize in a high-volume, fast-paced environment and drive a process to completion</li><li>You are a team player that does not shy away from taking ownership</li>"}],"text":"Merchants AML/CFT Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","descriptionBodyPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","applyUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713245102772,"descriptionPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","description":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","id":"3f4f687f-8599-4d5c-96d5-8af234c3b09d","lists":[{"text":"What You Will Do","content":"<li>Identify and define business opportunities that aligns with the overall merchant services business objectives</li><li>Translate business opportunities into a fit problem statement and able to measure the priority of the problem&nbsp;</li><li>Collaborate with Product Team to develop a merchant focused product in onboarding and support&nbsp;</li><li>Develop Go-To Market plan and oversee the product adoption from funnel conversion rates and merchant experiences during the process.&nbsp;</li><li>Monitoring the product life cycle and continuously improved the product with a data driven decision making process</li><li>Engaged sales and ops team to deliver the best onboarding and support experience for merchants</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of working experience, experience in product and project management is a plus.&nbsp;</li><li>Possess a strong sense of agency in navigating and creating clarity in ambiguous situations.</li><li>Ability to break down complex problems, identify use cases and solutions, and thrive in unstructured environments.</li><li>Comprehensive understanding of data, design, research, and business processes, with the ability to effectively collaborate with diverse teams.</li><li>Strong analytical and quantitative skills, with the capability to utilize data and metrics to support requirements and features.</li><li>Effective communication skills to articulate strategy, insights, priorities, and plans coherently to all levels of management.</li><li>Meticulous attention to detail, with a commitment to upholding high standards and managing multiple, competing priorities concurrently with minimal supervision.</li>"}],"text":"Onboarding & Support Business Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","descriptionBodyPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d","applyUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"Lending Operations","allLocations":["Jakarta"]},"createdAt":1720692666755,"description":"","descriptionPlain":"","id":"0ae5053b-3c5f-432a-9b69-b4cdefb01b79","lists":[{"text":"What You Will Do","content":"<li>Master all Consumer Lending Operations-related data points, including Customer Service, KYC, Telesales, and Transactional Data.</li><li>Manage all Operations Dashboards and Reporting to ensure timely and accurate availability.</li><li>Provide analytical insights leading to actionable plans with positive impacts for stakeholders.</li><li>Support the Head of Operation and other stakeholders in executing operational experimentation and enhancing workflow automation processes.</li><li>Lead, mentor and develop Operation BI team member.</li><li>Assist Operation stakeholders in dealing with Fraud investigation, Campaign Setup, and regulatory reporting and audit preparation</li><li>Analyze, evaluate, and initiate improvements in day-to-day operations for efficiency, effectiveness, and scalability.</li><li>Develop job automation to build Datamart-level tables in Big Query for Operational Dashboard Reporting.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's Degree in Engineering, Mathematics, Statistics, or a related discipline is required.</li><li>5 years of experience in a fast-paced environment, with a background in project management and data analytics.</li><li>Possesses strong analytical, planning, and problem-solving skills.</li><li>Proficient in SQL and Advanced Excel, with a high level of competence in working with numerical data sets. Knowledge of Python and experience in automating tasks is highly advantageous.</li><li>Familiarity with at least one business intelligence tool such as Google Data Studio (Looker), Power BI, or Tableau is preferred.</li><li>Ability to work independently with excellent time management skills, collaborating effectively with cross-functional teams to drive initiatives aligned with organizational objectives and Key Results (OKRs).</li><li>Exceptional communication and interpersonal skills, capable of articulating complex ideas to non-technical stakeholders with clarity and precision.</li><li>Familiarity with data warehousing concepts and methodologies is considered a plus.</li>"},{"text":"About The Team","content":"<li>Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</li><li>Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly. In the coming year, in light of our new GoTo collaboration, we have exciting plans to scale up our team in effort to field the massive growth of our data pool.&nbsp;</li>"}],"text":"Operation Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79","applyUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79/apply"},{"additionalPlain":"Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy & Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs\n","additional":"<div><span style=\"font-size: 10pt\">Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs</span></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720522525041,"descriptionPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","description":"<div><span style=\"font-size: 10pt\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","id":"719f7a78-460a-4496-9298-ca57b835b120","lists":[{"text":"What you will do","content":"<li>Manage operational relationships with Fleet partners</li><li>Gain understanding of the mechanics of Fleet management, and identify pain points</li><li>Provide first level support for Fleet partners to ensure their business can thrive sustainably</li><li>Enhance the dynamic relationships among Gojek, Driver Partners, and Fleet Partners</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 3 years work experience in relevant sectors, e.g. Operations, Process Improvement and Management</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in English and in Bahasa Indonesia</li><li>Strong sense of business and tech processes</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Operation Support Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","descriptionBodyPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120","applyUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120/apply"},{"additionalPlain":"About The Team\n\nThe Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful experience.The Trust & Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and stakeholders.If you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust & Safety team.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful </span><a href=\"http://experience.The\" style=\"font-size: 10pt\" class=\"postings-link\">experience.The</a><span style=\"font-size: 10pt\"> Trust &amp; Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and </span><a href=\"http://stakeholders.If\" style=\"font-size: 10pt\" class=\"postings-link\">stakeholders.If</a><span style=\"font-size: 10pt\"> you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust &amp; Safety team.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1708072107075,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","description":"<div><span style=\"font-size: 16px\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","id":"6f3368c9-6e84-489c-add3-4ad1fd4b9519","lists":[{"text":"What You Will Do","content":"<li>Provide regular analysis and reports on operational performance including compliance, escalations, quality, risk, and KPI tracking to guide decision-making and devise proactive solutions</li><li>Collaborate with cross-functional teams to build, automate, and improve on the availability, integrity, accuracy, and reliability of reporting, data logging, and data pipelines to be secure and compliant</li><li>Liaise with internal and external stakeholders for regulatory and compliance reports whenever needed, including issue investigation and report verification</li><li>Create and maintain performance management dashboards, visualizations, and trackers for Operations</li><li>Develop data-driven business insights and work with cross-functional teams to identify opportunities and implement new product features or system enhancements related to Trust &amp; Safety</li><li>Identify operational weaknesses and opportunities to help improve or innovate new processes and projects to drive user and vehicle quality, customer experience, and compliance to regulatory requirements</li><li>Prepare regulatory compliance reports to ensure adherence to relevant data protection, Insurance, earnings and safety regulations</li><li>Implement and maintain a good data management system to ensure the integrity, confidentiality, and availability of trust and safety-related data.</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in analytics and operations/compliance-related role</li><li>A wizard at working on and analyzing large datasets, with the ability to translate quantitative findings into action plan, demonstrated through understanding of&nbsp; statistical methods and modeling techniques.</li><li>Strong stakeholder and project management capabilities, with great attention to detail</li><li>Resilience and ability to take initiative in our constantly-changing fast-paced environment</li><li>Strong knowledge of SQL, Python, Google Suite, and MS Excel (advanced) is required</li><li>Experience in BI tools such as Tableau, Metabase, or Data Studio is a plus</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Operations Analyst, Data Operations (Trust & Safety)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519","applyUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><span style=\"font-size: 10pt\"><b>About the team </b></span></div><div><br></div><div><span style=\"font-size: 10pt\">At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</span></div>","categories":{"department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721275390563,"descriptionPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","description":"<div><span style=\"font-size: 10pt\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","id":"03e3c5dd-2c14-4737-820e-f32b6cccf632","lists":[{"text":"What you will do:","content":"<li>Monitor and analyze key performance indicators (KPIs) to drive continuous improvement in operations.</li><li>Build and maintain strong relationships with merchant partners, promptly addressing their needs and concerns.</li><li>Train, mentor, and manage a team of onboarding specialists to ensure high performance and professional development.</li><li>Collaborate with internal teams to ensure drivers, merchants, and customers receive exceptional service.</li><li>Stay updated with industry trends and competitor activities to keep GoMart ahead.</li><li>Identify opportunities for operational efficiencies and implement best practices across the team.</li><li>Prepare routine reports and present findings as the basis of rationale and recommendations for strategic decision-making</li><li>Develop and implement strategies to enhance the onboarding process and improve merchant satisfaction.</li>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Strong analytical thinking, insights generating, and complex problem-solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds and ability to manage small team&nbsp;</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written English</li>"}],"text":"Operations Manager - GoMart","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt;\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","descriptionBodyPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","hostedUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632","applyUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632/apply"},{"additionalPlain":"About the Team\n\nOur KYC team, a subsidiary of the Data Products and Infra Team , consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Operations, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers. \nWe are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our KYC team, a subsidiary of the Data Products and Infra Team , consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Operations, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers.&nbsp;</span></div><div><span style=\"font-size: 16px\">We are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"OneKYC","allLocations":["Jakarta"]},"createdAt":1722254499146,"descriptionPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n\n","description":"<div><span style=\"font-size: 16px\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div><div><br></div>","id":"c98e554f-20cd-4d37-80b7-46794ef7bedb","lists":[{"text":"What You Will Do","content":"<li>Managing both operations and project related KYC and KYB including but not limited to managing productivity and capacity plan for ops team both in house and in vendor, daily monitoring of team’s performance, staffing and work environment</li><li>PIC for vendor management both for MP and BPO, create a robust vendor scorecard to decide whether vendor will need to be replaced or not&nbsp;</li><li>PIC for complaint handling improvement for all issues related to KYC and KYB both for new users and existing users by considering the friction in the journey and cost optimization&nbsp;</li><li>Continuous cost and benefit analysis on the whole KYC and KYB process from Ops and Business perspective including but not limited to when leading projects or in day to day BAU</li><li>Identify key risks in the current lifecycle management process for various product under GoTo entity&nbsp;</li><li>Develop and implement AML related frameworks, policies and procedures&nbsp;</li><li>Liaise with OneKYC special project in implementing process improvement to improve quality or efficiency of key work in the KYC platform or other AML processes not supported by the KYC platform</li><li>Delivery on targets and objectives in line with timelines dictated by SLA's and quality expectations</li><li>Ensure preventive and detective KYC controls and monitoring programs are in place and provide adequate coverage by working closely with risk and fraud team&nbsp;</li><li>Taking a lead in KYC teams to generate the project plan including resource plan, prioritization, budget, test strategy in improving the current process or setting up a new one&nbsp;</li><li>Have flexibility and capability upon promoting project based on the Agile methodologies and supporting Scrum Master of development team</li><li>Manages the relationship and communications with key stakeholders across the Business, AML, Compliance, Risk, and product team in or outside GoTo</li><li>PIC for all audit related matters, be it internal and/or regulatory&nbsp;</li><li>Responsible for ensuring a seamless collaboration with all counterparts both internal and external of GoTo company.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A relevant Bachelor or Master Degree from reputable University</li><li>Should have at least 8 years of experience in a financial institution and have a background in leading big scale projects and process improvement with tangible result&nbsp;</li><li>Strong sense of operational risk and regulatory risk&nbsp;</li><li>Team player (adaptable, communicative, strategic, collaborative)</li><li>Analytical mindset (able to understand the context, find the correlation between topic, and draw the conclusion)</li><li>Problem-solving (able to link the information’s to solve the problem)</li><li>Experienced in creating BRD with the minimum point of problem statement, solution to implemented, cost and benefit analysis and impact analysis&nbsp;</li>"}],"text":"Ops and Project Manager - OneKYC","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div><div><br></div>","descriptionBodyPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb","applyUrl":"https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb/apply"},{"additionalPlain":"About the team \n\nThe Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721103093996,"descriptionPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","id":"90d1d8b9-75fb-4211-8d69-99412932f5ba","lists":[{"text":"What you will do","content":"<li>Work closely with business and support units to design and execute GoTo Financial payments advocacy.</li><li>Lead external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders to advance GoTo Financial’s mission to provide accessible and safe payment products to all Indonesian users.&nbsp;</li><li>Support Compliance and Regulatory Affairs matters in GoTo Financial&nbsp; Payments Compliance operations, which includes but is not limited to business/product reporting and approval process with the regulators, and technical regulatory assessment</li><li>Create and maintain the latest update of payments regulations databases and provide/disseminate assessment on such regulations to the internal units in GoTo Financial</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law/ Economics/Management/ Accounting and International Relations. Having a master’s degree would be an advantage.</li><li>At least 4 years of mixed experience in the area of public policy/public affairs, and/or regulatory compliance and past working experience in Bank Indonesia/ Otoritas Jasa Keuangan and Public Affairs consulting firms will be an advantage.&nbsp;</li><li>Advanced level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks and proactively choose the best solutions and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including building credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"Payments Compliance PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba","applyUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba/apply"},{"additionalPlain":"\n","additional":"<div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - People & Culture","location":"Jakarta","team":"HR Information Systems","allLocations":["Jakarta","Singapore"]},"createdAt":1718958420176,"descriptionPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","description":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","id":"8fe35112-8410-4cf3-9a50-4c7287e95b57","lists":[{"text":"What You Will Do","content":"<li><b>HRIS Management &amp; Operations: </b>Operate and administer end-to-end Workday as our HRIS platform, serve as technical lead for Workday Core HCM, Talent Management, Absence, and Compensation. Provide technical support on day-to-day HR processes such as operations, payroll, performance management, and merit cycle. Act as a subject matter expert on HRIS-related inquiries and troubleshoot any technical issues that arise.</li><li><b>Process Improvement: </b>Identify opportunities to streamline HR processes using HRIS, automate manual efforts, and increase overall efficiency. Partner with cross-functional teams to identify opportunities for improvement, gather requirements, design, recommend, and implement system-driven solutions.</li><li><b>System Implementation &amp; Integration: </b>Collaborate with partners (HR and IT team) to configure and optimize HRIS modules, workflows, and integrate with other systems such as Payroll, ATS, and Finance to create seamless data flows. Lead HRIS system update and implementation of new HRIS modules, working with vendors and internal teams to plan and execute the process smoothly and successful adoption by stakeholders.</li><li><b>Report Development: </b>Develop and maintain custom reports, dashboards, and visualizations within HRIS to provide insightful HR metrics and analytics to stakeholders.</li><li><b>User Access Management and Compliance: </b>Manage user access and permissions to ensure data security and privacy compliance. Ensure HRIS compliance with relevant data protection and privacy regulations. Monitor and audit HR data to maintain accuracy, quality, and integrity, implementing necessary corrections and preventive solutions.</li><li><b>Training: </b>Provide training to HR staff and end-users on using and familiarities with the HRIS in respective to their roles.</li>"},{"text":"What You Will Need","content":"<li>Proven experience (typically 5+ years) in HRIS management and optimization.</li><li>Strong proficiency with Workday and related HR systems (Lever, Degreed, Larona, etc).Strong understanding of HR processes and workflows, with the ability to translate business requirements into HRIS solutions.</li><li>Excellent project management and problem solving skills, capable of handling multiple initiatives in a fast-paced environment.</li><li>Strong influencing skills with the ability to communicate clearly and confidently with stakeholders.</li><li>Strong managerial and leadership skills with the ability to guide, develop, and mentor team members to make things happen.</li><li>Experience communicating effectively across teams in markets across the region.</li><li><b>Preferred Qualifications: </b>Certification in Workday in one of the following modules: Core HCM, Advanced Compensation, Reporting, Talent, Performance, or Absence Management. Experience in SaaS HR system configuration. Experience with downstream system integrations such as Google Workspace, Google Cloud Platform, Workato, and JIRA/Asana.</li>"}],"text":"People Systems Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","descriptionBodyPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57","applyUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57/apply"},{"additionalPlain":"About The Team\n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div><br></div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721379671434,"descriptionPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","description":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","id":"49388333-1938-4c06-b453-911eee08c53f","lists":[{"text":"What You Will Do","content":"<li>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. </li><li>Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis</li><li>Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</li><li>Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li>"},{"text":"What You Will Need","content":"<li>At least 3 years working experience in an analytical role&nbsp;</li><li>Proficiency in multiple analytic tolls with strong knowledge of SQL and experimentation process</li><li>Effective communication skills with the ability to present financial information clearly and concisely</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Strong business acumen with a data-driven approach to problem-solving and the ability to drive initiatives independently.&nbsp;</li><li>A confident communicator in verbal and written English</li>"}],"text":"Pricing & Supply Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","descriptionBodyPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f","applyUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f/apply"},{"additionalPlain":"Our GoFood Strategy & Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. \n\nThe gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably. \n\nWhen our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">Our GoFood Strategy &amp; Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">The gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">When our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721383021327,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","description":"<div><span style=\"font-size: 9pt\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","id":"0911a6fe-475a-498f-bf48-7d492e3d04d2","lists":[{"text":"What You Will Do","content":"<li><b>Strategize, experiment, and optimize: </b>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact <a href=\"http://analysis.Execute\">analysis.</a></li><li><b><a href=\"http://analysis.Execute\">Execute</a> and collaborate: Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</b></li><li><b>Explore:</b> Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li><div><br></div>"},{"text":"What You Will Need","content":"<li>BS/MS in Business, Engineering, Computer Science, Mathematics, Economics, Statistics, or equivalent experience</li><li>At least 4 years of working experience in an analytical role</li><li>Scientist thinking process that can work in increments and exponents, coupled with hypothesis-driven mindset</li><li>Proficiency in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with strong knowledge of SQL and experimentation process</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><div><br></div>"}],"text":"Pricing & Supply Senior Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2","applyUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2/apply"},{"additionalPlain":"Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714372709159,"descriptionPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","description":"<div><span style=\"font-size: 10pt\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","id":"44117b68-3ece-40ac-91c1-920caadfe5dd","lists":[{"text":"What You Will Do","content":"<li>Design and construct scalable streaming or batch data pipelines to meet various business requirements.</li><li>Establish reliable monitoring and alerting systems to assess data pipeline performance.</li><li>Identify potential bottlenecks in the system and optimize as needed.</li><li>Manage the data science infrastructure to streamline model development and deployment.</li><li>Mentor team members by conducting code reviews and sharing knowledge.</li>"},{"text":"What You Will Need","content":"<li>Experience with streaming processing and Change Data Capture (CDC) tools such as Debezium, Flink, Kafka, etc. is necessary.</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Docker, RDBMS, and NoSQL Databases is desirable.</li><li>Proficiency in Python and SQL is expected.</li><li>Must be self-driven, with a strong sense of ownership, and capable of working independently to solve problems and develop solutions.</li><li>Project management skills to successfully drive large-scale projects from initiation to completion are needed.</li><li>Excellent communication skills, including proficiency in English, are required.</li><li>Understanding of machine learning techniques and algorithms is advantageous.</li>"}],"text":"Principal Data Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","descriptionBodyPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","hostedUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd","applyUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd/apply"},{"additionalPlain":"About the Team - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","additional":"<div><b style=\"font-size: 10pt\">About the Team</b><span style=\"font-size: 10pt\"> - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721188007441,"descriptionPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","description":"<div><span style=\"font-size: 10pt\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","id":"0197001e-f39c-4d55-b6b9-1cf247bd17b0","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutions, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li>At least 8 years of relevant experience</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Principal Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","descriptionBodyPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0","applyUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive. \n\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and </span><a href=\"http://automations.You\" style=\"font-size: 16px\" class=\"postings-link\">automations.You</a><span style=\"font-size: 16px\"> are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.&nbsp;</span></div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Gurugram"]},"createdAt":1721890257186,"descriptionPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","id":"6f2d563a-182c-4c23-8c72-9d2a4f563ed9","lists":[{"text":"What You Will Do","content":"<li>Improves code structure and architecture in service of testability and maintainability</li><li>Has in-depth understanding of multiple programming languages/paradigms, and highly proficient in one technology area, including how it interacts with the system</li><li>Leads new language/framework POC within a technical focus area, participates in the design review process, and providing constructive criticism for improvement</li><li>Is accountable for the operationalization of the tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Is accountable for ensuring that their squad has strong sets of documentations and journals of how their design and architecture evolves over time</li><li>Ensures predictability, quality &amp; throughput of their squad's delivery</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad's deliveryPrioritizes work based on understanding the trade-off between quality, tech-debt, and delivery</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: significant experience in one or many of the areas including golang/python programming, Events/stream processing framework development, engineering tooling and user facing interfaces, Kubernetes administration</li><div><br></div>"}],"text":"Principal Engineer - Cloud Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px;\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9","applyUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9/apply"},{"additionalPlain":"About the Team :\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div><span style=\"font-size: 11pt\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721116359853,"descriptionPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","id":"7c3c43e3-8b8d-48a4-a590-7754207b2d1b","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, reliable and fault tolerant platforms for one of the world's fastest growing unicorns</li><li>You will be responsible for the overall delivery and the solution architecture of the offerings your team will be working on</li><li>You will own prioritization of initiatives to maximize achievements on objectives and growth for engineering at GoTo</li><li>You should understand product engineering and have empathy with problems and pain points of Product Engineers. &amp; you will continuously contribute to make their experience better</li><li>You shall write code because you like to. You never stop wanting to get better at it</li><li>Communicate, collaborate and work effectively with product teams distributed in a global environment</li><li>You will be responsible for the overall growth, learning and happiness of your team</li><li>Is independently responsible for coaching, development, and career management for the team</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have experience in leading a team of 6-8 engineers and owning the overall delivery for the teams</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Have experience with recruitments and staffing management to help in building a sustainable team</li><li>Can take recruitment and staffing responsibilities depending to balance out the growth</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: Significant experience in one or many of the areas including Clojure programming, Stream processing framework development, engineering tooling and user facing interfaces</li>"}],"text":"Principal Software Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt;\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b","applyUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b/apply"},{"additionalPlain":"About the Team\n\nOur Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1715060912791,"descriptionPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"426f18b4-739e-4da0-a74b-446c349c0a31","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Collaborate with cross functional teams (Mobile, DevOps, UX, QA etc.) on execution and delivery</li><li>Partner with the team to define and execute the feature roadmap</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"What You Will Need","content":"<li>Should have at least 7 years of hands-on experience in designing, developing, testing and deploying applications at scale</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Principal Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31","applyUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719211012411,"description":"","descriptionPlain":"","id":"fc7c3413-6c4f-42bd-a048-70387bd490a4","lists":[{"text":"What you will do:","content":"<li>Process Analysis and Assessment: 1. Conduct comprehensive assessments of existing business processes to identify inefficiencies, bottlenecks, and areas for improvement. 2. Gather and analyze data to understand process performance and identify root causes of issues. 3. Develop process maps, flowcharts, and other documentation to visualize current state processes.</li><li>Improvement Strategy Development: Collaborate with stakeholders to design and develop strategies for process improvement, focusing on enhancing efficiency, quality, and customer satisfaction.</li><li>Implementation of Improvements: 1. Lead cross-functional teams in the implementation of process improvements, ensuring alignment with business goals and objectives. 2. Develop &amp; monitor detailed project plans, timelines, and milestones to guide improvement initiatives.</li><li>Change Management and Communication: Drive change management efforts &amp; communicate effectively to ensure smooth adoption of new processes and practices.</li><li>Performance Monitoring and Reporting: 1. Establish key performance indicators (KPIs) to measure the effectiveness of process improvements. 2. Conduct post-implementation reviews to assess the impact of changes and identify further improvement opportunities.</li><li>Continuous Improvement Culture: Provide mentorship and guidance to stakeholders on process improvement methodologies and tools.</li>"},{"text":"What you will need:","content":"<li>Bachelor's degree in Business Administration, Industrial Engineering, Operations Management, or a related field. A Master's degree is preferred.</li><li>Proven experience in business process improvement, process engineering, or related <a href=\"http://roles.Strong\" class=\"postings-link\">roles.</a></li><li>Strong knowledge of process improvement methodologies (e.g., Lean, Six Sigma, Kaizen).</li><li>Excellent analytical and problem-solving skills.</li><li>Exceptional project management skills, with experience leading cross-functional teams.</li><li>Strong communication and interpersonal skills, with the ability to influence and drive change.</li><li>Proficiency in process mapping and analysis tools (e.g., Visio, Lucidchart).</li><li>Ability to manage multiple projects and priorities in a fast-paced environment.</li>"},{"text":"Preferred Skills:","content":"<li>Fluent in English&nbsp;</li><li>Experience with data analysis tools (e.g., Excel, Tableau, Power BI).</li><li>Knowledge of change management principles and practices.</li><li>Familiarity with ERP and CRM systems, especially Salesforce</li><li>Experience in training and development related to process improvement.</li>"}],"text":"Process Improvement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4","applyUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4/apply"},{"additionalPlain":"About The Team\n\nGoTo Procurement  Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.\n\nAs a team, we are not only concerned about the company but also the professional and personal growth & aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">GoTo Procurement&nbsp; Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we are not only concerned about the company but also the professional and personal growth &amp; aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things</span></div>","categories":{"department":"HoldCo - Finance","location":"Jakarta","team":"Procurement","allLocations":["Jakarta"]},"createdAt":1721729730710,"descriptionPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","id":"c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","lists":[{"text":"What Will You Do","content":"<li>Lead and execute the Vendor Selection process to ensure that the company is getting what it really needs as well as the best deal in the market, following GoTo Procurement Procedure while adhering to relevant Policies and Procedures within the organization and collaborating with the relevant stakeholders and Subject Matter Expert (SME) to support comprehensive evaluation. The vendor selection process will be for both Tactical and Strategic bidding and aim for cost optimization targets and ensure the proper documentation to establish transparency and accountability</li><li>Drive cost optimization initiatives to support organization operating cost optimization through the execution of Procurement activities, including mitigation of any relevant risks within the Source-to-Pay process and supply chain.&nbsp;</li><li>Owning the Source-to-Pay process by ensuring a seamless transition throughout the steps, starting from capturing business needs up to Vendor Payment</li><li>Increase Procurement’s technology and platform utilization and target for SLA optimization and Sourcing Quality</li><li>Develop a Sourcing competencies framework as part of people development within the Procurement Sourcing organization</li><li>Build the right vendor market and network as well as internal stakeholders, to support the collaborations within Procurement processes</li><li>Lead and collaborate Vendor Value Creation Program together with Critical/Valued vendors to deliver innovation, better speed to market, productivity, asset utilization, sustainability, etc.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Bachelors of business, supply chain management, or any other related field. Preferably has been working in Procurement too</li><li>At least 2 years in procurement areas, preferably from multinational companies</li><li>Strong business and commercial mindset</li><li>Excellent negotiation, organizational, and collaboration skills</li><li>Excellent interpersonal and communication skills</li><li>Excellent project management skills</li><li>Advanced in verbal and written English proficiency</li>"}],"text":"Procurement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","descriptionBodyPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","applyUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274/apply"},{"additionalPlain":"About the Team\n\nThe Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.\n\nWe have helped simplify payments for over 750,000 merchant partners, over  1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.</div><div><br></div><div>We have helped simplify payments for over 750,000 merchant partners, over&nbsp; 1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1720599307040,"descriptionPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","description":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","id":"83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","lists":[{"text":"What You Will Do","content":"<li>Conduct merchant research and analyze user data to identify trends and pain points.</li><li>Working with Business Intelligence teams, writing queries and learning to set up product metric tracking dashboards&nbsp;</li><li>Help summarize merchant interviews as insights</li><li>Collaborate with product managers and designers to define product requirements.</li><li>Develop and present product recommendations based on data analysis.</li><li>Assist with creating product prototypes and user testing.</li><li>Stay up-to-date on industry trends and competitor analysis.</li>"},{"text":"What You Will Need","content":"<li>Strong analytical skills with proficiency in data analysis tools, candidates with experience will be preferred</li><li>The ability to write SQL queries is strongly preferred</li><li>Excellent communication and presentation skills.</li><li>A passion for product development and a keen eye for detail.</li><li>Familiarity with the Indonesian payments landscape is a plus.</li>"}],"text":"Product Analyst Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","descriptionBodyPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","applyUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8/apply"},{"additionalPlain":"About The Team\n\nThis vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.  \n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>This vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.&nbsp;&nbsp;</div><div><br></div>","categories":{"department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1718084687109,"descriptionPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","description":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","id":"a1ebb8d4-0af0-4707-9efb-8f52aa781c44","lists":[{"text":"What You Will Do","content":"<li>Help define the roadmap, goals, and vision for the product experience</li><li>Work with design leads, product heads, marketing and engineers to build/improve user experience and ways of working towards that vision</li><li>Manage projects, solve complex problems, and enable your team to deliver delightful solutions that drive impact</li><li>Build systems for design documentation &amp; help establish processes to ensure seamless collaboration</li><li>Mentor and coach a team of designers, improve stakeholders grasp and application of design thinking</li><li>And most importantly, make sure your team is engaged well and building things that make them successful</li>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in product design, but still willing to learn more about product research</li><li>Proficiency in all areas of digital product design; visual design, user experience design, user research prototyping, advocacy and building showcases. Additional exposure to motion, sound, video and other craft are welcome</li><li>Ability to draw insights from both qualitative &amp; quantitative data, and further identify problem areas to work on.</li><li>Ability to design, advocate and prioritize user research with our research team</li><li>Knowledge in design fundamentals, such as design thinking frameworks, HCI principles, and being able to take on a structured approach in solving problems</li><li>Excellent organizational, project management, and collaboration skills to manage a wide range of stakeholders</li>"},{"text":"","content":"<li><br></li>"}],"text":"Product Design Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44","applyUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44/apply"},{"additionalPlain":"About the Team\n\nThe Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. \n\nWe’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers. \n\nThe Loyalty, Incentives & Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more. \n\nWe are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .\n\n\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. </div><div><br></div><div>We’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers.&nbsp;</div><div><br></div><div>The Loyalty, Incentives &amp; Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more.&nbsp;</div><div><br></div><div>We are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .</div><div><br></div><div><br></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718798053606,"descriptionPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","id":"e407433b-435a-4607-89bd-5faf51cf622e","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of a senior product designer, and follow the predefined process set forth by the team</li><li>Able to comprehend the product briefs and be able to present the ideas/solutions to the team under the supervision of the product design lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Define end-to-end wireframe and wireflow for features using standard wireframing tools</li><li>Document the design process for each feature, such as research findings, ideations, usability tests, release, and monitor the impact after the product release</li><li>Contribute to the team cadence discussion and make occasional short presentations to the team, as well as present team’s updates if needed</li><li>Proactively seek/give feedback from other stakeholders to make sure concepts are meeting the intended project goal</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of relevant experience in the product design industry</li><li>Familiar with data and can identify problem areas, further map out the user journey, and break the problems into smaller chunks</li><li>Use basic analytics tools to gather customer data (funnel)&nbsp;</li><li>Possess a good knowledge of design fundamentals, such as design thinking framework and other frameworks to develop products</li><li>Able to sketch the ideas into wireframes, learn how to make wireflow, and do wireframing for well-defined features</li><li>Good knowledge of the tools, such as Overflow, Miro, Sketch, Figma, or similar ones that are widely used by Product Designers</li><li>Knowledge of design validation, either through quantitative or qualitative research</li><li>Preferably some knowledge of service design and experience with working on mobile app design</li>"}],"text":"Product Designer - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e","applyUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e/apply"},{"additionalPlain":"About The Team\n\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718166115141,"descriptionPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","description":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","id":"b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirements and the impact of each feature, as well as the go-to-market strategy to ensure adoption of the features</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in product management experience</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Growth","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","applyUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba/apply"},{"additionalPlain":"About The Team\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. \n\nThe Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.\n","additional":"<div><b>About The Team</b></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology.&nbsp;</div><div><br></div><div>The Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.</div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719305116114,"descriptionPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","id":"6f05ee4a-fa49-4aca-8990-c6607cd7cf09","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched&nbsp;</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirement and the impact of each feature as well as the go to market strategy to ensure adoption of the features.&nbsp;</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of total experience, with 2-3 years experience specifically in product management</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09","applyUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09/apply"},{"additionalPlain":"About The Team\nWork hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Work hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721026583842,"descriptionPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","id":"92f4b266-849a-42f2-b7e0-859360a003d8","lists":[{"text":"What You Will Do","content":"<li>Develop and own end-to-end project and program plans that outline scope, goals, deliverables, required resources, and timelines&nbsp;</li><li>Monitor progress of projects and programs to highlight plan deviations,, resolve issues and propose corrective actions to remove implementation blockers</li><li>Oversee and synergise multiple projects to ensure prompt completion within scope, and within budget</li><li>Work closely with internal and external stakeholders from cross-functional teams to assess feasibility of initiatives, develop the scope, and deliverables</li><li>Act as a point of escalation for project and program initiatives’ issues, mediate issues, and ensure stakeholder’s expectations are met</li>"},{"text":"What This Role Needs","content":"<li>At least 3 years of work experience in the financial industry, having worked in mid to large-scale cross-functional projects and/or programs, particularly in lending (consumer and/or loan lending products, such as cash loan, buy now pay later, merchant financing, vehicle financing, etc)</li><li>Well-versed in speaking &amp; writing in English, Bahasa Indonesia; Mandarin is a plus</li><li>Comfortable in fronting conversations with senior leaders and C-suite leaders</li><li>Able to work under pressure with strict implementation timelines</li><li>Possess a strong ability to analyze data and generate insights to value-add to the projects/programs</li><div><b>Soft Skills</b></div><li>Stakeholder management skills</li><li>Sharp business acumen</li><li>Attention to details</li><li>Time management</li><div><b>Hard Skills</b></div><li>Project / ProgramManagement Skills, ideally CAPM certified will be advantageous</li><li>Six Sigma Skills, ideally Six Sigma GreenBeltcertified will be advantageous</li><li>Knowledgeable about financial industry laws &amp; regulations &amp; being compliant at all times</li><li>Good working knowledge of Project Management tools like Jira, Lark and Google Suites</li><li>Knowledge about e-commerce / transport industries is a plus</li>"}],"text":"Program Manager, Consumer Lending - #10310","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","descriptionBodyPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8","applyUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8/apply"},{"additionalPlain":"About the Team\nOur KYC team, a subsidiary of the Payment Platform Team, consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Product, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers. \nWe are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><span style=\"font-size: 16px\">Our KYC team, a subsidiary of the Payment Platform Team, consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Product, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers.&nbsp;</span></div><div><span style=\"font-size: 16px\">We are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"OneKYC","allLocations":["Jakarta"]},"createdAt":1722254311646,"descriptionPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n","description":"<div><span style=\"font-size: 16px\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div>","id":"22a1f73e-1fed-464e-a66c-72139d289c14","lists":[{"text":"What You Will Do","content":"<li>Closely liaise with Ops team to address pain point and issues in the ops process or issues that might triggered customer complaints, and come up with solution to address the issue and oversee the implementation and measure result</li><li>Together with Product &amp; Compliance team, refine all the existing processes to achieve company goals and ensure that user journey complies with country regulations at all times</li><li>Initiate a process review and benchmark to come up with solutions on how best to create a seamless KYC and KYB process to onboard “good user”</li><li>Continuous cost and benefit analysis on the whole KYC and KYB process from Ops and Business perspective including but not limited to when leading projects or in day to day BAU&nbsp;</li><li>Work closely with the Fraud team to identify trends of fraud patterns during KYC and KYB submission, figure out solutions to address the issue, collaborate with the product team in delivering the solution from testing to production deployment, from UAT to sanity testing&nbsp;</li><li>Work closely with Product team to do the continuous review and refine User Interface and User Experience flow throughout the whole KYC and KYB process&nbsp;</li><li>Drive all the initiatives and discussions related to KYC and KYB process including but not limited to, new projects, impact, issue and target by closely collaborating with internal and external counterpart&nbsp;</li><li>Lead the initiative for complaint handling related KYC and KYB process not only related to newly implemented process but also to address issue that might happen from incorrect ops process</li><li>Lead eKYC solution with external clients from start to finish and continue with maintaining the relationship with external clients to ensure a seamless integration and create a seamless user journey.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A relevant Bachelor or Master Degree such as Business Administration, Management, Computer Science, etc. and PMP or PMI certification is a plus</li><li>Minimum of 5 years of experience as a Project Manager and have a background in leading big scale, multiple projects and process improvement with tangible result</li><li>Should have a working experience in a financial institution is a plus</li><li>Strong sense of operational risk and regulatory risk&nbsp;</li><li>Team player (adaptable, communicative, strategic, collaborative)</li><li>Analytical mindset (able to understand the context, find the correlation between topic, and draw the conclusion)</li><li>Problem-solving (able to link the information’s to solve the problem)</li><li>Experience in creating BRD with the minimum point of problem statement, solution to implemented, cost and benefit analysis and impact analysis&nbsp;</li><li>Proficiency in English both active and passive is a must</li>"}],"text":"Project Manager - OneKYC","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div>","descriptionBodyPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n","hostedUrl":"https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14","applyUrl":"https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14/apply"},{"additionalPlain":"About the Team\n\nOur Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720752364065,"descriptionPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","id":"20554643-fae8-4082-8797-7d5fd44db8b0","lists":[{"text":"What You Will Do","content":"<li>Develop and run complex analysist to support business decision</li><li>Design and develop dashboards to track business and product performance</li><li>Leverage data from dashboards as well as other sources to derive insights as a basis of rationale and recommendations in decision-making processes</li><li>Running a project management for multiple projects at different stages &amp; complexity</li>"},{"text":"What You Will Need","content":"<li>At least 2-3 years of experience in a business analytics or business intelligence role at a tech company</li><li>End-to-end the problem-solving mindset</li><li>Strong communication and project management skills</li><li>Strong proficiency in SQL, Microsoft Excel, and PowerPoint</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"Project Manager - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0","applyUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0/apply"},{"additionalPlain":"About the Team\n\nInsurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721362323598,"descriptionPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","id":"8906c3d0-c77f-4a0a-8f25-8b738515ede3","lists":[{"text":"What You Will Do","content":"<li>Attend daily standup meetings, sprint planning, and backlog reviews</li><li>Communicate project status to internal and external teams promptly</li><li>Analyze and estimate product features from a testing perspective</li><li>Ensure software quality by adopting best practices in software development</li><li>Design, develop, and execute automation scripts using open-source tools</li><li>Identify, record, document, and track bugs thoroughly</li><li>Perform thorough regression testing when bugs are resolved</li><li>Collaborate with product managers to clarify feature requirements and ensure comprehensive test coverage</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of experience in professional testing</li><li>Strong understanding of unit testing concepts and problem-solving using online resources</li><li>Deep knowledge of Manual &amp; Automation test methodologies and principles</li><li>Capability to create testing scenarios/scripts using test management tools</li><li>Experience in Mobile and API Testing in both manual &amp; automation contexts</li><li>Proficiency with automation tools like Jira, Selenium, RestAssured, ​​TestNg using Java (preferably), Postman, Gitlab, Kafka</li><li>Good understanding of logging mechanisms, messaging services, and pipelines</li><li>Experience working with the AGILE process methodology and strong interpersonal communication skills for collaboration with remote teams</li>"}],"text":"QA Engineer - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3","applyUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717052781419,"descriptionPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","description":"<div><span style=\"font-size: 10.5pt\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","id":"4ba1eea8-feed-4843-be2e-93a21f0eadb1","lists":[{"text":"What Will You Do","content":"<li>Perform exploratory data analysis using SQL and present interesting findings to business stakeholders to drive business and strategic decisions</li><li>Design and analyze experiments to improve service quality and quantity</li><li>Build and maintain self-serve data products such as dashboards (Looker &amp; Tableau) and tables to reduce time to insights</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Should have at least 2-3 years of practical experience in <a href=\"http://SQL.Prior\" class=\"postings-link\">SQL.</a></li><li><a href=\"http://SQL.Prior\" class=\"postings-link\">Prior</a> experience with applied statistics, experimental design is a <a href=\"http://plus.Able\" class=\"postings-link\">plus.</a></li><li><a href=\"http://plus.Able\" class=\"postings-link\">Able</a> to tell a coherent data narrative using visualization tools and able to set best practices in data visualization to convey a product insight through impactful <a href=\"http://graphs.Proven\" class=\"postings-link\">graphs.</a></li><li><a href=\"http://graphs.Proven\" class=\"postings-link\">Proven</a> ability to recognize business needs and ability to communicate with multiple stakeholders including PMs, business and <a href=\"http://operations.Balance\" class=\"postings-link\">operations.</a></li><li><a href=\"http://operations.Balance\" class=\"postings-link\">Balance</a> attention to detail with swift execution.</li><div><br></div>"}],"text":"Region Analytics Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","descriptionBodyPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1","applyUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1/apply"},{"additionalPlain":"About The Team\n\nAs an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">As an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713428751727,"descriptionPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","description":"<div><b style=\"font-size: 10pt\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","id":"0489939a-c571-4d5f-adaa-95ceac8912c5","lists":[{"text":"What You Will Do: ","content":"<li>Responsible for completed orders and profit and loss target achievement</li><li>Provide analytics to support operations team such as Supply Reliability, Fraud rules, Driver’s Engagement etc. at the regional level</li><li>Deploy defined strategies from operations perspective during the process of establishing the new area of service as well as optimizing existing area</li><li>Ensure SOP and legal compliances in the region</li><li>Support Regional Operation Head to oversee all districts and branches operations</li><li>Analyze driver states &amp; measure efficiency of various driver badges to generate more high quality drivers in the region</li><li>Support Regional Operation Head in product changes roll out in the region</li>"},{"text":"What You Will Need:","content":"<li>Having at least 5 years experience in supply chain, preferably at the managerial level and from Multi National Company or similar experience in the Ride Hailing/ On Demand Service Industry</li><li>Strong analytical thinking and problem solving skills using various improvement tools and methods (preferably have prior exposure to SQL)</li><li>Having good understanding about supply and demand planning</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Lead team / project as well as persuade stakeholders to ensure speed &amp; quality of project / initiative</li><li>Proficiency in to converse in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Region Operations Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","descriptionBodyPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5","applyUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718002291914,"descriptionPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","description":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","id":"f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","lists":[{"text":"What You Will Do","content":"<li>Monitor and analyze transactions and user activities to detect suspicious patterns and potential fraud.</li><li>Conduct thorough investigations of suspected fraud cases and recommend control actions.</li><li>Develop and implement strategies to mitigate fraud risks across the platform.</li><li>Collaborate with product, engineering, and operations teams to enhance fraud prevention measures.</li><li>Prepare detailed reports on fraud incidents, including root cause analysis and actionable recommendations.</li><li>Provide regular updates to senior management on fraud trends, risks, and mitigation efforts.</li><li>Stay updated on the latest fraud trends, tools, and best practices to continuously improve detection and prevention strategies.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Finance, Accounting, Business, Computer Science, or a related field.</li><li>2+ years of experience in fraud risk management or a related role.</li><li>Strong analytical and problem-solving skills, with proficiency in data analysis tools (e.g. SQL, Python, Excel) and experience with visualization tools (e.g. Tableau, DataStudio)</li><li>Excellent communication and interpersonal skills.</li><li>Ability to work independently and as part of a team in a fast-paced environment.</li><li>Strong attention to detail and commitment to accuracy.</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Risk Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","descriptionBodyPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","applyUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710738954272,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"60d37414-287e-4552-a0d0-accf1737d0ce","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>3-4 years of related payment risk experience, preferably on the acquiring side and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business side</li>"}],"text":"Risk Analyst - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce","applyUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce/apply"},{"additionalPlain":"In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1704856901936,"description":"","descriptionPlain":"","id":"5611e062-e094-4da3-ab1c-75c85cf62194","lists":[{"text":"What You Will Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volumes of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutions, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers&nbsp;</li>"},{"text":"What you will need","content":"<li>3+ years of experience developing ML solutions</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Risk Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194","applyUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713334327811,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"a61cda6c-82fd-4daf-aabf-3db91e01684f","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>5-8 years of related payment risk experience, preferably on the mobile apps and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business sid</li>"}],"text":"Risk Manager - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f","applyUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715584452832,"descriptionPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","description":"<div><b style=\"font-size: 16px\">About the team:</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","id":"d6ac496c-e0ad-4669-b594-ede9bf8d55f9","lists":[{"text":"What you will do:","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed,</li><li>Resolve account issues and complaints,</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis,</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments,</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation,</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients,</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms.</li>"},{"text":"What you will need:","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area,</li><li>A minimum of 3 years of experience in business management, sales, or project management is mandatory. </li><li>Prior experience in e-commerce and managing key accounts will be a plus point,</li><li>Fluency in both Bahasa and English is required,Able to multitask, prioritize, and manage time efficiently,</li><li>Ability to negotiate, persuade and influence others,</li><li>Excellent interpersonal, communication, presentation and analytical skills,</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills,</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners.</li>"}],"text":"Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the team:</b></div><div><span style=\"font-size: 16px;\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","descriptionBodyPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9","applyUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9/apply"},{"additionalPlain":"The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood campaigns.\n\nIn the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales team.When our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their efficiency.\n\nIn our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood </span><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">campaigns.</span></a></div><div><br></div><div><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales </span><a href=\"http://team.When\" class=\"postings-link\"><span style=\"font-size: 10pt\">team.When</span></a><span style=\"font-size: 10pt\"> our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their </span><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">efficiency.</span></a></div><div><br></div><div><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Excellence","allLocations":["Jakarta"]},"createdAt":1714365620212,"descriptionPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","description":"<div><span style=\"font-size: 10pt\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","id":"f39be622-e287-41df-bcb2-7389478a1be4","lists":[{"text":"What you will do","content":"<li>Oversee the performance tracking and monitoring of the whole Enterprise Sales Team</li><li>Ensure that the Enterprise Sales team has all the data they need to achieve their target for all KRs</li><li>Act as a consultant and discuss with the EKAMs on the business needs/challenges that their merchants are facing</li><li>Provide data and data driven insights to EKAMs to help address said challenges</li><li>Assist in performing periodical business analysis, tailored to each merchant based on their business needs</li><li>Assist in the daily tasks and smooth operations of Enterprise Sales Support</li><li>Liaise with HO team for merchant x sales account management, target, tracker, etc</li><li>Liaise with other teams (e.g. BI, Salestech) when there is new KRs / data point that needs to be analysed</li><div><br></div>"},{"text":"What you will need","content":"<li>At least 2 years of relevant experience in data analytics&nbsp;</li><li>Good business acumen, able to develop analysis with good storyline and flow</li><li>Proficient in SQL, Google BigQuery and the reporting thereof is an advantage</li><li>Proficient in handling large amount of data using tools/softwares such as google sheet, metabase and datastudio</li><li>Great communication and understanding skill, able to explain technical terms in simple, understandable manner</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>High interest and eagerness to analyse different parts of businesses to help achieve growth</li><li>Clear understanding of Gojek services and the tech industry</li><div><br></div>"}],"text":"Sales Support Senior Associate, Enterprise","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","descriptionBodyPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4","applyUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4/apply"},{"additionalPlain":"About The Team\n\nOur Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1720004794044,"descriptionPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","id":"bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","lists":[{"text":"What You Will Do","content":"<li>Identify areas of business growth by structuring problem statements and forming hypotheses</li><li>Query and process large amounts &amp; complex data sets of our customers’ behavior, usage patterns, statistical trends, and funnel performance&nbsp;&nbsp;</li><li>Synthesize actionable insights and solutions from the data analysis</li><li>Own and drive the proposed initiatives to achieve business objectives</li><li>Visualize and communicate findings in an easy-to-understand, concise, and clear format</li><li>Experiment with the growth initiatives and continuously iterate to find areas for improvements</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience working in a data-driven environment, previous experience in the tech industry is a bonus</li><li>Proficient in data query, data processing, and charting to synthesize actionable insights from large sets of complex data</li><li>Strong structured problem-solving abilities to identify issues, form hypotheses, and generate recommendations</li><li>Ability to create and execute experimentation plans or A/B testing on key growth initiatives&nbsp;</li><li>Excellent project and stakeholder management skills to ensure all planned initiatives are met on high quality and on time</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Ability to learn new things and adapt your priorities quickly within a fast-paced environment</li>"}],"text":"Savings Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","descriptionBodyPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","applyUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1698657930091,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"376aefd9-6d6c-4e57-8040-a3b0dd416d26","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2 to 4 years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26","applyUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719471574933,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2-4+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","applyUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Consumer Experience","allLocations":["Bengaluru"]},"createdAt":1716277072995,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"0169bd4d-f352-4162-8e8e-2c09df5b8db4","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Growth","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4","applyUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788743352,"descriptionPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","id":"08aa1472-d91f-4c5d-b5e0-e88163943bcd","lists":[{"text":"What You Will Do","content":"<li>Design, implement, and maintain the company’s IT infrastructure, ensuring scalability, reliability, and performance.</li><li>Manage servers, networks, databases, and cloud services to support business operations and growth.</li><li>Develop and implement comprehensive cybersecurity strategies to protect the company’s assets and data.</li><li>Conduct regular security assessments, vulnerability scans, and penetration testing to identify and mitigate risks.</li><li>Oversee the installation, configuration, and maintenance of hardware and software systems.</li><li>Ensure data integrity and availability through effective backup and disaster recovery planning.</li><li>Develop and enforce IT policies and procedures to ensure security, compliance, and efficient operations.</li><li>Ensure compliance with relevant regulations and industry standards.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, Information Technology, or a related field. A Master’s degree or relevant certifications (e.g., CISSP, CISM) is a plus.</li><li>Minimum of 7 years of experience in IT infrastructure management, cybersecurity, or a related role, with at least 3 years in a leadership position, preferably in the cryptocurrency or fintech industry.</li><li>Strong understanding of IT infrastructure, network administration, and cybersecurity practices.</li><li>Proven track record of developing and implementing successful IT and security strategies.</li><li>Excellent analytical, problem-solving, and organizational skills.</li><li>Strong leadership, communication, and interpersonal skills.</li><li>Preference qualifications in high-frequency trading</li>"}],"text":"Security and System Infra Manager (CISSP) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd","applyUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd/apply"},{"additionalPlain":"About the Team\n\nThe Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial <a href=\"http://platforms.It\" class=\"postings-link\">platforms.It</a> is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719832381686,"descriptionPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","id":"9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","lists":[{"text":"What You Will Do","content":"<li>Perform security design on applications (web, mobile) and infrastructures (cloud, on-premise)</li><li>Perform security code review (manual, automated) on applications and infrastructures</li><li>Ensure applications and infrastructures are secure by design, follow secure design principles, and adopt secure coding practices</li><li>Identify security gaps and vulnerabilities, and propose appropriate controls and remediations</li><li>Propose solutions to wide-ranging security problems</li><li>Raise security awareness among the Product, Engineering, and Infrastructure team by conducting security training, and having regular security discussions</li><li>Bridge communication between the broader Information Security team with the Product, Engineering, and Infrastructure team</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, or a related field</li><li>Minimum 3 years of experience in Software Engineering, preferably on web and mobile application</li><li>Minimum 3 years of experience in Information Security, preferably in application and cloud security</li><li>Good knowledge of common secure design principles and secure coding practices</li><li>Good knowledge of common adversarial techniques, tactics, and procedures&nbsp;</li><li>Ability to learn new things quickly and independently</li><li>Ability to communicate effectively, preferably in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Security Engineering Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","descriptionBodyPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","applyUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12/apply"},{"additionalPlain":"About the Team\n\nThe Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.\n\nCTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.</div><div><br></div><div>CTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721369663762,"descriptionPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","id":"767d8980-5402-488d-b62c-222c0b4a0bfc","lists":[{"text":"What You Will Do","content":"<li><b>Observe</b>: Monitor the surface, deep, darkweb, and listen to your intelligence-sharing circles.</li><li><b>Analyze</b>: Through understanding of the internal landscape assess the (predicted threat). Support the incident response investigation, when needed.</li><li><b>Disrupt</b>: disrupt the effectiveness of the threats by various means.</li><li><b>Report</b>: Communicate timely, simply, and effectively the threat and key recommendations.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, Networking, and Cyber Security.</li><li>Working experience with one or multiple categories of tools (open source or commercial): Link Analysis Tools, Threat Modeling Tools, (Threat) Feed Aggregators, Threat Intelligence Platforms (TIP’s), Digital Risk Protection platforms, Malware Sandboxes, SOAR, SIEM or EDR.</li><li>5-7 Years of working experience (strong mid-level or senior in cyber security), relevant degree (bachelor or higher), or reputable industry certification (e.g.: ISC2, GIAC, Offsec, EC Council) preferred.</li><li>Extensive working experience in the CTI field is preferred, candidates from the following affiliated fields are alternatively also preferred: SOC, Vulnerability Management (VAPT), Penetration Testing, or Digital Forensics Incident Response (DFIR).</li><li>Possess critical thinking and problem-solving skills.</li><li>Leadership, experience in mentoring junior members, and stakeholder management skills are a must. You will be leading multiple important initiatives across the teams/companies.</li><li>Proficiency in English and Indonesian, both in written and oral form.</li><li>Outstanding reporting skills: content, delivery, clarity, brevity, and presentation.</li>"}],"text":"Senior Cyber Threat Intelligence Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt;\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","descriptionBodyPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc","applyUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719213882004,"descriptionPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","description":"<div><b style=\"font-size: 10pt\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","id":"1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","lists":[{"text":"What you will do","content":"<li><b>Design, build, and maintain the ETL </b>from various sources into the data mart; Troubleshoot and resolve data-related issues, including data discrepancies, anomalies, and performance bottlenecks</li><li>End to end data project ownership and collaboration with cross-functional teams to understand data requirements and design data models that support the organization's single version of truth</li><li>Ensure the quality, accuracy, and reliability of our data by implementing data validation checks and error handling mechanisms</li><li>Develop and customize Tableau/Google Sheet/Looker studio reports that provide actionable insights to stakeholders</li><li>Create and maintain documentation related to data structures, processes, and transformations for future reference</li>"},{"text":"What you will need","content":"<li>4 years of experience in <b>Data Analyst/BI Analyst/</b>BI Engineer</li><li>Advance knowledge of <b>SQL </b>and Python</li><li>Able to lead a small team also can work as a individual contributor</li><li>Hands on experience with data visualization Tableau Looker studio/Google Sheet</li><li>Strong analytical and problem-solving skills, with keen attention to detail</li><li>Excellent communication skills (English is a must) to collaborate with technical and non-technical stakeholders</li><li>Having a people manager experience is a plus</li>"}],"text":"Senior Data Analyst (Analytics Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","descriptionBodyPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","applyUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264696268,"descriptionPlain":"\n","description":"<div><br></div>","id":"6d8ebb73-2348-423d-847e-b8a8408ac1ed","lists":[{"text":"What You Will Do","content":"<li>Gather business requirements to support BI projects.</li><li>Explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What you will need ","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Senior Data Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed","applyUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed/apply"},{"additionalPlain":"Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719472943608,"descriptionPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","description":"<div><span style=\"font-size: 10pt\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","id":"90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","lists":[{"text":"What You Will Do","content":"<li>Design, build, and maintain data streaming solutions.</li><li>Troubleshoot and resolve data-related issues, including discrepancies, anomalies, and performance bottlenecks.</li><li>Ensure scalability and reliability of the data streaming platform.</li><li>Collaborate with data engineers, data scientists, and other stakeholders to understand requirements and provide tailored streaming solutions.</li><li>Monitor and optimise performance to ensure low latency and high throughput.</li><li>Perform regular maintenance tasks, including upgrades and patches.</li><li>Document design, implementation, and maintenance processes.</li><li>Stay updated with the latest advancements in data streaming technologies.</li>"},{"text":"What You Will Need","content":"<li>3 - 6 years of experience as a Data Engineer.</li><li>Strong programming skills in Java.</li><li>Hands-on experience in real-time streaming with Apache Flink.</li><li>Experience working with Apache Kafka and Kubernetes.</li><li>Experience working with any cloud platform and NoSQL database.</li><li>Strong analytical and problem-solving skills, with keen attention to detail.</li><li>Excellent communication skills for collaborating with technical and non-technical stakeholders.</li><li><b>Good to have: </b>Programming in Go/Python, IAC using Terraform, Batching ETL and exposure to open data lakehouse architecture is a plus</li><li><br></li>"}],"text":"Senior Data Engineer - Data Streaming","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","descriptionBodyPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","applyUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720774001435,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"976d0171-5a06-43e2-9ec6-e0b45345c6fd","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd","applyUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd/apply"},{"additionalPlain":"About The Team\nThe GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><span style=\"font-size: 10pt\">The GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1684915963454,"descriptionPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","description":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","id":"a539cdc1-109f-48e8-9b24-1a831b735f01","lists":[{"text":"What Will You Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volume of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers</li>"},{"text":"What You Will Need","content":"<li>6+ years of experience developing ML solutions, 2-3 years of <b>fraud risk experience in account takeover, scam, and abuse</b></li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt;\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","descriptionBodyPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01","applyUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1713852044349,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"34f6146a-c482-407c-a31c-72ac9bb90a7c","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>Analyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist - Marketplace (Singapore)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c","applyUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1705993404249,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"86673189-b5e2-4ace-b1a3-5ab20f14d84d","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist (India)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d","applyUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707210044551,"descriptionPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","description":"<div><span style=\"font-size: 10pt\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","id":"c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","lists":[{"text":"What You Will Do","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What You Will Need","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li>"}],"text":"Senior Data Warehouse Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","descriptionBodyPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","applyUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69/apply"},{"additionalPlain":"About The Team\n\nOur Data Warehouse team is based in Jakarta & Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nOur team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data Warehouse team is based in Jakarta &amp; Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1713498805305,"descriptionPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","description":"<div><span style=\"font-size: 10pt\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","id":"2b430ba4-210e-4db6-a63e-c11459a0304f","lists":[{"text":"What Will You Do?","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What Do You Need? ","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li><li>You’re passionate about your customers and always bring questions back to what will serve them best</li>"}],"text":"Senior Data Warehouse Engineer - India","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt;\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","descriptionBodyPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f","applyUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f/apply"},{"additionalPlain":"About the Team\n\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719199384298,"descriptionPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"905d4e32-1699-4fcc-96b3-aa6aa0b462cb","lists":[{"text":"What You Will Do","content":"<li>Analyze database performance data to identify bottlenecks and implement optimizations to enhance system efficiency and reliability</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li><li>Design and develop custom tools and utilities to facilitate various database operations, leveraging programming languages such as Ruby, or Golang</li><li>Ensure database security best practices are implemented and maintained, including access control, encryption, and compliance with relevant regulations</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Continuously evaluate database infrastructure usage and performance metrics to identify opportunities for cost optimization</li><li>Benchmarking tests to evaluate the impact of configuration changes on database performance. This helps in identifying optimal parameter values and fine-tuning configurations for different types of workloads.</li><li>Tuning database configuration parameters to optimize database performance for the application</li>"},{"text":"What You Will Need","content":"<li>8+ years experience as a DBA Engineer in managing databases for a large production environment</li><li>Expert in various database management systems (MySQL/PostgreSQL, Redis, MongoDB, and Elastic Search), and techniques for optimizing databases and understanding the basic cloud platform (AWS or GCP)</li><li>Advanced skills in a programming language like Ruby or Golang, and possess deep expertise in shell scripting</li><li>Excellent experience with Linux is required and expertise in server configuration, maintenance, and troubleshooting</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)</li><li>Proficient in seamlessly conducting database upgrades, ensuring uninterrupted operations and system integrity.</li><li>Proficiency in configuring and utilizing monitoring and diagnostic tools to pinpoint and address database performance issues effectively</li><li>In-depth knowledge of the various configuration parameters tailored to the specific database management system</li>"}],"text":"Senior Database Administrator Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb","applyUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb/apply"},{"additionalPlain":"About the Team\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719198420770,"descriptionPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"28fe323b-ed5f-482b-b71d-ed60662bed8b","lists":[{"text":"What You Will Do","content":"<li>Develop automation scripts and tools for provisioning, deployment, monitoring, and backup/recovery of databases using infrastructure as code (IaC) principles</li><li>Implement robust monitoring and alerting systems for database performance metrics&nbsp;</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Maintain version-controlled configurations for database servers, ensuring consistency and repeatability across environments via IaC</li><li>Automate routine tasks such as database backups, schema migrations, and data archiving to improve operational efficiency</li><li>Develop database high availability and replication solutions to meet the requirements of critical applications.</li><li>Develop standardized operational procedures within the DBaaS framework to ensure the consistent provision of highly available solutions.</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li>"},{"text":"What You Will Need","content":"<li>5+ years Experience as a DevOps Engineer with a focus on database management</li><li>Hands-on experience with cloud platforms (AWS or GCP)</li><li>Proficiency in scripting languages such as Go, Shell, and Ruby for automation tasks</li><li>Experience with infrastructure as code tools (e.g., Terraform, CloudFormation) for provisioning and managing database resources</li><li>In-depth knowledge of database systems such as MySQL, PostgreSQL, MongoDB, etc., including configuration, optimization, and troubleshooting</li><li>Strong understanding of CI/CD practices and tools</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)&nbsp;</li><li>Experience in configuration management tools (eg: ansible) for database patching and maintenance automation</li>"}],"text":"Senior DevOps Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b","applyUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1706508052225,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","id":"da8d4a37-f5a4-4436-8743-58c787781285","lists":[{"text":"What You Will Do","content":"<li>Take ownership of one of OKR related to demand and growth that leads to revenue and profitability from one of Gojek product’ business; defines the strategy and roadmap for the team to achieve it by combining multiple initiatives (e.g., content/communication, vouchers/promotion, product changes)</li><li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Build predictive model or clustering model to allocate the promo allocation efficiently</li><li>Run multiple experiments to validate hypothesis in fast pace iteration cycle</li><li>Drives the team for prioritization, strategy, and focus on solutions to solve user problems</li><li>Introduce beneficial business changes through well-written strategy documents and validate the strategy and hypotheses through robust experimentation and statistical approach</li><li>Optimize and automate solutions by leveraging Data Sciences resources</li><li>Perform feedback loop and retroactive analysis of the team performance and operation to evaluate and improve their impact on Gojek’'s North Star Metrics</li><li>Proactively review the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Present findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis.</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 5 years of working experience with a minimum of 1-2 year of leadership experience</li><li>Proficiency in data analysis tools and programming languages such as Python, R, SQL, and data visualization tools like Tableau or Power BI. Strong analytical skills to interpret complex data sets and extract actionable insights</li><li>High proficiency in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficiency in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Understanding of business operations, strategies, and objectives. The Consumer Analytics Lead should be able to connect analytical insights to business goals and contribute to overall decision-making</li><li>Data Management: Familiarity with data collection, storage, and management best practices</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Experience in a SaaS, Marketplace, Food Delivery, or other technology company is a plus</li>"}],"text":"Senior Growth Manager - Food & Ads","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285","applyUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285/apply"},{"additionalPlain":"About The Team\n\nThe mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.\n\nThe Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.\n\nIn addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.</div><div><br></div><div>The Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.</div><div><br></div><div>In addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.</div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Jakarta","team":"-","allLocations":["Jakarta","Bengaluru"]},"createdAt":1721729849780,"descriptionPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","description":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","id":"e6583aa0-7097-4e6f-9f91-7f24d5441156","lists":[{"text":"What You Will Do","content":"<li>Develop and communicate a clear product vision and roadmap for data science/GenAI platforms/products, and Streaming/Batching Pipeline products.</li><li>Lead the end-to-end product development lifecycle from ideation through launch and iteration, aligning product strategies with business objectives and stakeholder needs.</li><li>Collaborate closely with cross-functional teams, including engineering, data science, analytics, and operations, to deliver high-quality products.</li><li>Prioritize features and improvements based on data analysis, user feedback, and business impact.</li><li>Utilize data-driven insights to inform product decisions and measure the impact of product features.</li><li>Implement and track key performance indicators (KPIs) to ensure product success and drive continuous improvement.</li><li>Foster a culture of experimentation and iteration to optimize product performance and user satisfaction.</li><li>Communicate product updates, progress, and challenges effectively to stakeholders at all levels of the organization.</li>"},{"text":"What You Will Need","content":"<li>5+ years of product management experience, specializing for at least 3 years in data science platforms, data pipelines, or related products.</li><li>Proven track record of successfully managing complex technical products in fast-paced environments.</li><li>Strong understanding of data science, and data engineering principles.</li><li>Experience with streaming and batching data processing technologies such as Apache Kafka, Spark, Flink, etc will be a big plus.</li><li>Strong analytical and problem-solving skills, leveraging a data-driven approach to decision-making.</li><li>Excellent verbal and written communication skills.</li><li>Demonstrated leadership abilities, capable of inspiring and motivating cross-functional teams.</li>"}],"text":"Senior Product Manager, Data Science Platform and Data Products","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156","applyUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156/apply"},{"additionalPlain":"About The Team\n\nOur Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. </div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1717126992883,"descriptionPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","id":"50c8a826-2076-40a3-a829-b96b29c9647f","lists":[{"text":"What You Will Do","content":"<li>Conduct research to understand merchants needs and behavior and analyze product performance data to identify opportunities&nbsp;</li><li>Developing and executing a data-driven marketing strategy that aligns with the overall business objectives</li><li>Create product positioning and messaging to differentiate our products from competitors</li><li>Creating and managing marketing campaigns across various channels, including search, social media, and email marketing by working together with both internal and external stakeholders to deliver the plan</li><li>Developing and managing referral or other marketing programs to drive merchant acquisition</li><li>Identify, develop, implement, and refine consumer-focused lifecycle &amp; retention marketing strategies</li><li>Continuously monitor and analyze data to create campaign or marketing reports</li><li>Running A/B tests and analyzing results to optimize conversion rates and user acquisition.</li>"},{"text":"What You Will Need","content":"<li>3+ years working experience in Tech, Bank, Consulting or Marketing Agencies</li><li>2+ years experience in marketing or growth roles</li><li>Customer obsession and passionate in marketing</li><li>Strong analytical skills, data-driven and delighted with statistical analysis and figures</li><li>Strong communication skills, collaborative spirit, delighted to work with other stakeholders (BI/Data, Business, Product, Leadership)</li><li>Strong business sense and problem-solving skills</li>"}],"text":"Senior Product Marketing Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f","applyUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1722243132222,"descriptionPlain":"About The Role\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","id":"afd9e752-82f0-4b4f-a4ef-5d86dcce1063","lists":[{"text":"What You Will Do","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed</li><li>Resolve account issues and complaints</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms</li>"},{"text":"What This Role Needs","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area</li><li>At least 6 years of experience in business management, sales, or project management is mandatory. Prior experience in e-commerce and managing key accounts will be a plus point</li><li>Fluency in both Bahasa and English is required</li><li>Able to multitask, prioritize, and manage time efficiently</li><li>Ability to negotiate, persuade and influence others</li><li>Excellent interpersonal, communication, presentation and analytical skills</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners</li>"}],"text":"Senior Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","descriptionBodyPlain":"About The Role\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063","applyUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063/apply"},{"additionalPlain":"About the Team\n\nThe Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721742951306,"descriptionPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","description":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","id":"099498bc-c171-4505-97d7-3a432d302e14","lists":[{"text":"What You Will Do","content":"<li>Work and collaborate in Financial systems technical projects, especially in SAP ABAP and SAP BTP technologies</li><li>Collaborate with cross-functional and cross-department teams to analyze complex business requirements and design scalable solutions</li><li>Develop and maintain technical specifications, design documents, and other project artifacts</li><li>Provide technical support and guidance to development teams, ensuring high-quality code delivery</li><li>Participate in code reviews, ensuring adherence to coding standards and best practices</li><li>Contribute to the development of technical architecture and design patterns, providing recommendations for improving performance, scalability, and maintainability</li><li>Stay up-to-date with the latest SAP technologies and trends, and evaluate new technologies for potential adoption</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of experience in SAP application development, with a focus on SAP ABAP and SAP BTP technologies</li><li>Proven track record of delivering successful scalable technical projects</li><li>Strong technical skills in ABAP OO, SAP Gateway, CDS, AMDP</li><li>Strong technical skills in SAP BTP or SAP Integration Suite</li><li>Knowledge on modern integration, Unix environment, cloud platform technologies, and other stacks is a plus</li><li>Excellent communication and interpersonal skills, with the ability to work effectively in a team environment</li><li>Strong analytical and problem-solving skills, with the ability to think creatively and strategically</li>"}],"text":"Senior SAP Technical","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","descriptionBodyPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14","applyUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1706837996316,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"93b5e2e0-272f-4091-b7aa-fafc06ca67c4","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>4-6+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"Senior SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4","applyUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4/apply"},{"additionalPlain":"About our Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About our Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1700733541559,"descriptionPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","description":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","id":"472ae629-87cb-4f8c-bb69-eae35cf3751e","lists":[{"text":"What you’ll do","content":"<li>Develop and implement test automation tools and frameworks to ensure continuous testing of product features</li><li>Collaborate with product managers and engineers to understand requirements, document test cases, and define rollout/release strategies</li><li>Perform performance, load, and scalability testing for new features and product releases.</li><li>Debug and diagnose defects uncovered during testing to determine root causes. Log bugs accurately and communicate issues clearly to engineering teams</li><li>Monitor systems in production to identify and troubleshoot defects or anomalous behavior.</li><li>Stay up-to-date with new testing methodologies and tools</li><div><br></div><div><br></div>"},{"text":"What you’ll need","content":"<li>5+ years experience in a QA, SDET or DevX role, with expertise in test automation</li><li>Proficiency with one or more programming languages like Java, Go, Kotlin, Python</li><li>Experience testing complex distributed systems and microservices architectures</li><li>Understanding of SQL and NoSQL databases</li><li>Familiarity with technologies like Kafka, Docker, Kubernetes</li><li>Knowledge of financial systems, mobile apps, or SaaS products is a plus</li><li>Excellent verbal and written communication skills</li>"}],"text":"Senior SDET - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e","applyUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721811900324,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","id":"153e42ca-cf5b-4f43-b09e-58eabda1e5fa","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 4 years of experience in professional testing in App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin, experience with Flutter is a plus)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa","applyUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team :</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1722316158497,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role :</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</span></div>","id":"78d59624-b02e-4370-b23b-25677dfb1b20","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 5 years of experience in professional testing in Microservices/API/App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role :</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20","applyUrl":"https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1713506558950,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"076bd021-0157-42a4-89fd-51d9f236e490","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Payment Widget & Vendor Gateway","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490","applyUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490/apply"},{"additionalPlain":"About the Team\n\nThe Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.\n \nSome of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few. \n \nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.</div><div>&nbsp;</div><div>Some of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few.&nbsp;</div><div>&nbsp;</div><div>Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Marketplace","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1698659237440,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","id":"8d7ae844-168c-4e78-843a-94aceb7b1a66","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of relevant, hands-on experience with either  Golang, or Java</li><li>Ability to go in-depth across tech stacks used in the product</li><li>Experience working on large-scale, event-driven microservice architecture with active use of Kafka; ability to architect solutions based on this pattern</li><li>Familiarity with basic programming principles such as SOLID and TDD</li><li>Intermediate experience with Linux OS; ability to troubleshoot issues</li><li>A solid understanding of why we need to test code; experience implementing tests</li><li>Ability to understand/discuss design and performance trade-offs in complex systems</li>"}],"text":"Senior Software Engineer  - Marketplace","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66","applyUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66/apply"},{"additionalPlain":"About the Team\n\nWe are a team of developers, designers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers, designers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1722246725855,"descriptionPlain":"About the Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nThis role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more</span></div><div><br></div>","id":"d8170197-90ca-4f87-a48d-d1a3175538ce","lists":[{"text":"What You Will Do","content":"<li>Code, Design, prototype, perform reviews and consult in building highly scalable, reliable, and fault-tolerant systems</li><li>Containerisation and deployment of microservices on Kubernetes</li><li>Auto-scaling and monitoring performance of the streaming Infrastructure and applications by using Prometheus and Grafana or similar tools</li><li>Collaborate with the team to ensure that the service level objectives and agreements are achieved</li><li>Communicate and collaborate effectively with product, data science teams</li><li>Continue to stay abreast of the latest technologies in Event processing and Big Data space to inform/suggest new technologies and best practices to trial</li><li>Mentor and guide other engineers in the team</li>"},{"text":"What You Will Need","content":"<li>At least 4+ years of software engineering experience</li><li>Experience with containerization and DevOps, including Docker and Kubernetes</li><li>Experience with Kafka and stream processing like Flink or Spark Streaming</li><li>Must have hands-on experience using any of the cloud platforms (AWS, GCP, Azure), with thorough knowledge of cloud concepts</li><li>Demonstrated ability to take initiative and accountability for achieving results</li><li>Strong interpersonal and communication skills</li><li>Passion for learning new things and solving complex engineering blockers</li>"}],"text":"Senior Software Engineer - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">This role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nThis role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce","applyUrl":"https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711358848361,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"68f907a3-329f-411b-af2d-a66b38243919","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 5 years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>You have working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>You have Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, XGBoost, Keras</li>"}],"text":"Senior Software Engineer - Data Science Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919","applyUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919/apply"},{"additionalPlain":"About the Team\n\nWe are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.\n\nWe keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.\n\nThe Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.</span></div><div><br></div><div><span style=\"font-size: 16px\">We keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.</span></div><div><br></div><div><span style=\"font-size: 16px\">The Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721898140037,"descriptionPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","id":"57bb5e7f-9ea0-462f-ac36-5717b49d0380","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li><div><br></div>"},{"text":"What You Will Need","content":"<li>4-5 years of relevant experience. Hands-on in either Golang or Java</li><li>The ability to go into depth and breadth across tech stack used in the product vis-a-vis backend services, machine learning, data engineering, web development, data and analytics, infrastructure</li><li>Has worked on large scale event driven microservices architecture with an active use of Kafka and can architect solutions based on this pattern</li><li>Is familiar with basic programming principles such as SOLID and TDD</li><li>Has intermediate experience with Linux and is able to troubleshoot issues</li><li>Understands why we need to test code and has implemented tests</li><li>Able to understand/discuss design and performance trade offs in complex systems</li><div><br></div>"}],"text":"Senior Software Engineer - Go-food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px;\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380","applyUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718187134939,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"53c0b8a9-1a83-4c34-9a59-b5170ce54193","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Senior Software Engineer - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193","applyUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789054175,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","id":"fda395d6-457d-4a03-aaa1-33d513c3960b","lists":[{"text":"What You Will Do","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Software Engineer (Android) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b","applyUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b/apply"},{"additionalPlain":"About the Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713939159820,"descriptionPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","id":"d3b7122b-692b-4815-8aa9-f1d0259bccd5","lists":[{"text":"What Will You Do","content":"<li>Develop Java backend applications for the company, including web applications and server-side applications.</li><li>Be responsible for participating in the entire software development process, from requirement analysis to design, development, testing, and deployment, ensuring that our software products run efficiently and stably. The most significant thing is taking responsibility for results.</li><li>Architect and engineer robust, high-performance systems that can effortlessly handle scale, maintain reliability, ensure security, and gracefully handle faults.</li><li>Craft and refine our product vision into iterative Minimum Viable Products (MVPs), refining them as needed for scalability and adaptability.</li><li>Stay at the forefront of technology trends, continuously evaluating and incorporating new tools and methodologies to supercharge our development efforts.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","descriptionBodyPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5","applyUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789283382,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","id":"769b7391-e6fd-4923-9a92-e060f14e451d","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis, and MySQL.</li><li>Contributed to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization. Therefore, in addition to technical prowess, a keen understanding of financial business and self-motivation are emphasized.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>3+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Highly preferable experience in Golang</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d","applyUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d/apply"},{"additionalPlain":"About the team \n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the team </b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713777541586,"descriptionPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","description":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","id":"ad7a1160-4d07-4f4a-a2d3-c362afac18ac","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis and MySQL</li><li>Contribute to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred</li><li>Familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis</li><li>Familiar with Linux operating systems, understand database principles, and proficient in using databases like MySQL and Oracle</li><li>Good coding style and code specifications, and be able to independently complete project development</li><li>Good communication skills and teamwork spirit, and be able to collaborate effectively with other developers</li><li>knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Backend) - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","descriptionBodyPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac","applyUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710229562529,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"10dbc666-80f8-4250-85ee-59fa92d056aa","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Golang.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Good understanding of the full life cycle of the data warehouses.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Data Warehouse)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa","applyUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788927036,"descriptionPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","id":"bcd00ee0-2fb3-43c1-8401-ef184283ccc8","lists":[{"text":"What You Will Do","content":"<li>Design, build, deliver, and own development lifecycle from inception to production</li><li>Collaborate with the UI/UX team to write, design, and build high-quality front-end code and reusable components</li><li>Participate in and be responsible for front-end architecture design, and program decision-making, as well as creating technical standards and specifications;</li><li>Try improving engineering standards, tooling, and processes after understanding the business and team’s needs</li><li>Lead others through example, mentorship, teaching, code reviews, advocating, and maintaining suitable engineering standards for the team</li><li>Maintain close relations cross-department and gain from their expertise/share your learnings with them</li>"},{"text":"What You Will Need","content":"<li>3-4+ years of proven track record in JavaScript/ Typescript, CSS , HTML, DOM, network protocol, and other front-end related technologies, have in-depth experience in at least one of the mainstream front-end frameworks (React/ Vue /Angular, etc.) and understand the implementation principle</li><li>Good product awareness, service awareness, and sense of responsibility, can be independent and attention to user experience</li><li>Problem-Solving: Exceptional problem-solving skills with a track record of analyzing complex technical challenges and providing innovative solutions.</li><li>Communication: Excellent communication skills, with the ability to effectively convey technical concepts to both technical and non-technical stakeholders.</li><li>Leadership: Strong leadership experience, including mentorship, and technical guidance</li>"}],"text":"Senior Software Engineer (Front End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8","applyUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789167169,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","id":"e6c36118-5d4e-444b-922c-68e03c2ab82e","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Flutter and iOS.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3+ years of experience with iOS development and Flutter combined</li><li>Proficient in Swift programming, Cocoa, Xcode, the iOS SDK, Dart, and Flutter</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar).</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e","applyUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1708271973710,"descriptionPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","id":"389c0346-14e0-40e5-85c3-48d830db73b4","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Swift.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3 to 6+ years of experience with iOS development</li><li>Proficient in Swift programming, Cocoa, Xcode, and the iOS SDK</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar)</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Money Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","descriptionBodyPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4","applyUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899734506,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"449dd201-2d4d-47a0-9cd4-c7ddec91c88e","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data streaming products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Java.</li><li>Good understanding of real-time data streaming technologies like Flink, spark etc.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Real-Time Data Streaming)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e","applyUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1716821917651,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"8afd4278-a5a8-43f2-8718-2986433f2ddb","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.&nbsp;&nbsp;</li>"}],"text":"Senior Technical Program Manager - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb","applyUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717153383212,"descriptionPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","description":"<div><span style=\"font-size: 9pt\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","id":"3377f50a-d56f-42e0-acc5-b69d405a37a9","lists":[{"text":"What You Will Do","content":"<li>Identify and pursue strategic partnership opportunities that align with company goals - B2B in financial and non financial sectors</li><li>Negotiate terms and agreements with partners to drive mutual commercial successDevelop and maintain strong relationships with external partners to foster long-term collaboration</li><li>Collaborate with partners to create joint business plans aimed at achieving quarterly (QoQ) and yearly (YoY) growth targets</li><li>Monitor and analyze partnership performance, providing insights and recommendations for improvement</li><li>Work closely with internal teams, including sales, marketing, product, and finance, to ensure partnership initiatives are aligned with company objectives and obtain their successful buy in to projects and programs</li><li>Facilitate effective communication and collaboration across departments to gain buy-in for partnership strategies</li><li>Act as a liaison between partners and internal stakeholders to address any issues and optimize partnership outcomes</li><li>Be the first hand to handle issues related to the partnership and escalate the issue to the right parties (internal and external) to be solved</li><div><br></div>"},{"text":"What You Will Need ","content":"<li>Minimum Bachelor’s degree</li><li>Minimum 5 years of professional experience in partnership development or business development in companies such as start-ups, technology companies, management consulting, banking, or Fortune 500 companies</li><li>Data Analysis: Strong ability to crunch data and perform detailed data analysis. This includes interpreting complex datasets to derive actionable insights and support decision-making.</li><li>P&amp;L Understanding: Good understanding of Profit and Loss statements, with the ability to analyze financial performance and identify <a href=\"http://trends.Business\" class=\"postings-link\">trends.</a></li><li><a href=\"http://trends.Business\" class=\"postings-link\">Business</a> Acumen: Solid business acumen, enabling the development, management, and execution of business agreements and contracts. This involves a deep comprehension of business operations and strategic <a href=\"http://planning.Critical\" class=\"postings-link\">planning.</a></li><li><a href=\"http://planning.Critical\" class=\"postings-link\">Critical</a> Thinking and Problem Solving: Draws sound conclusions based upon a mixture of analysis and experience. Able to identify breakthrough solutions during tough negotiations or large-scale implementations with strategic <a href=\"http://partners.Communications\" class=\"postings-link\">partners.</a></li><li><a href=\"http://partners.Communications\" class=\"postings-link\">Communications</a> Skills: Promotes an environment of open communication. Convinces and engages others by using compelling arguments. Able to rigorously manage a portfolio of projects with strategic partners, unblock issues &amp; risks and manage expectations to ensure they are completed within target timelines and stakeholder <a href=\"http://expectations.Stakeholder\" class=\"postings-link\">expectations.</a></li><li><a href=\"http://expectations.Stakeholder\" class=\"postings-link\">Stakeholder</a> Management: Ability to develop strong, long lasting relationships with both internal and external stakeholders at all levels. Persuades and influences effectively by building support for ideas and initiatives through the effective presentation of facts and evidence. Identifies and anticipates that the partner and stakeholder needs to gain their commitment. Owns the end-to-end relationship with equivalent team and functional leads both internally and <a href=\"http://externally.B2B\" class=\"postings-link\">externally.</a></li><li><a href=\"http://externally.B2B\" class=\"postings-link\">B2B</a> Negotiation Skills: A fair, unbiased mediator and uses diplomacy and tact to diffuse tense situations comfortably</li><li>Resiliency : Demonstrates resilience &amp; composure, even in difficult or adverse circumstances. Makes and carries through unpopular or difficult decisions that are in the best interest of the team. Is able to resist the pressure to make quick decisions where due consideration is <a href=\"http://required.Abilities\" class=\"postings-link\">required.</a></li><li><a href=\"http://required.Abilities\" class=\"postings-link\">Abilities</a> to navigate and execute in a highly ambiguous environmentLocal candidates is a must</li><div><br></div>"}],"text":"Senior/Partnership Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt;\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","descriptionBodyPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","hostedUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9","applyUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9/apply"},{"additionalPlain":"About the Team\n\nAs a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.\n\nOur team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>As a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.</div><div><br></div><div>Our team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705293453270,"descriptionPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","id":"9b2d9240-3315-4b28-a7d6-73e2a097c8d7","lists":[{"text":"What You Will Do","content":"<li>Proactively monitor and troubleshoot system performance, identifying and addressing potential issues.</li><li>Collaborate with development teams to design and implement scalable and resilient system architectures.</li><li>Develop and maintain automation tools to streamline processes and enhance overall system efficiency.</li><li>Participate in incident response activities, conducting root cause analysis</li><li>Contribute to the ongoing improvement of reliability, scalability, and performance of critical infrastructure.</li><li>Work closely with cross-functional teams to align SRE efforts with broader organizational goals.</li>"},{"text":"What You Will Need","content":"<li>Solid understanding of cloud platforms such as GCP, and expertise in deploying and managing services within these environments.</li><li>In-depth knowledge of containerization technologies like Docker and orchestration tools such as Kubernetes</li><li>Proficiency in programming languages like Python, Go, or Java, with a strong software engineering foundation</li><li>Able to manage small teams and also can work as an individual contributor</li><li>Familiarity with Linux System, monitoring and logging tools to ensure comprehensive system visibility such as Prometheus, Grafana, and ELK stack</li><li>Proven track record of implementing and maintaining automation for deployment, scaling, and system orchestration.</li>"}],"text":"Site Reliability Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","descriptionBodyPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7","applyUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7/apply"},{"additionalPlain":"About the Team \n\nOur Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.\n\nHaving a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.  \n\nWe are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Our Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.</div><div><br></div><div>Having a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.&nbsp;&nbsp;</div><div><br></div><div>We are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717664713208,"descriptionPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","id":"f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","lists":[{"text":"What Will You Do ","content":"<li>Be the person in charge to create social media campaign and content; from observing trends and references, brainstorming, planning to execution (including schedule and post)</li><li>Develop social media campaigns strategies collaborate with other stakeholders&nbsp;&nbsp;</li><li>Create KOL strategy collaborate with stakeholders and third parties</li><li>Utilizing social media tools to analyze social media campaign, content, and KOL to gather insight and action plan</li><li>Collaborate with brand marketing to deliver/support marketing needs</li>"},{"text":"What Will You Need","content":"<li>At least 3-5 years related work experience from an advertising agency or start-up</li><li>Strong writing, editing, and proof-reading skills</li><li>Ability to communicate ideas clearly; a strong analytical, data-driven mindset</li><li>Broad knowledge of social media landscape, platforms, and technologies</li><li>Have interest in digital platforms, particularly in social media, and a willingness to learn more about this digital space</li><li>Strong team player with a proactive attitude and a creative/innovative mind to collaborate with multiple stakeholders</li><li>Strong analytical abilities to read, interpret, and utilize data, and to come up with actionable points for optimization and/or experimentation</li><li>Robust and detail-oriented to handle multiple works</li>"}],"text":"Social Media Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","descriptionBodyPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","applyUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898426994,"descriptionPlain":"\n","description":"<div><br></div>","id":"180b3e9e-cfb9-471d-8c30-410aef031535","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features &amp; participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team &amp; be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment &amp; work closely on the production environment, maintaining product’s&nbsp; uptime, reliability and SLOs</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby Proficient in OOP, SQL, Design Patterns</li><li>Experience with data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer  - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535","applyUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535/apply"},{"additionalPlain":"About the Team \n\nMxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).\n\nCore areas that we focus on - \nDeveloper Experience and Tooling: We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.\n\nFoundation and Building Blocks: This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!\n\nApp Excellence and Insights Tooling: The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">MxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).</span></div><div><br></div><div><b style=\"font-size: 16px\">Core areas that we focus on - </b></div><div><b style=\"font-size: 16px\">Developer Experience and Tooling: </b><span style=\"font-size: 16px\">We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.</span></div><div><br></div><div><b style=\"font-size: 16px\">Foundation and Building Blocks:</b><span style=\"font-size: 16px\"> This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!</span></div><div><br></div><div><b style=\"font-size: 16px\">App Excellence and Insights Tooling: </b><span style=\"font-size: 16px\">The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697010103248,"descriptionPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","id":"3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","lists":[{"text":"What You Will Do ","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need ","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Software Engineer - Android","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px;\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","applyUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897603986,"descriptionPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"96562e50-0bf7-4a14-a910-4ef63f16d451","lists":[{"text":"What You Will Do","content":"<li>Build large-scale and high-performance services to develop simple, easy-to-use products for our unique end customers</li><li>Design and develop a highly maintainable and reliable Android app</li><li>Write clean and tested code, mostly in Kotlin for Android native environment</li><li>Coordinate with other teams (Product Management, UX/Design, Backend Engineering, and Quality Engineering teams) on building and managing the Android app</li><li>Implement tech excellence in the Android development environment</li><li>Help in a constant exploration of new technology and tools</li><li>Deliver solutions that bring a positive impact to low-income communities through up-to-date software technologies</li><li>Going forward, you will have to work on flutter application as well</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience in software engineering</li><li>Strong knowledge of Kotlin, Android tools and framework, and Android Studio</li><li>Good skill in unit tests. Plus points for UI tests</li><li>Experience in using app vitals and performance monitoring systems</li><li>Experience building an end-to-end system, preferably for a large user base</li><li>Strong attention to detail, particularly on software engineering fundamentals, testing methodologies, and quality</li><li>Familiarity with Android design patterns</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - Android (Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451","applyUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451/apply"},{"additionalPlain":"About the Team\n\nThe Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).\n\nOne of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.\n\nOff hours, you’d probably find us hang out, dinner together or playing games\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).</div><div><br></div><div>One of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.</div><div><br></div><div>Off hours, you’d probably find us hang out, dinner together or playing games</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697610584742,"descriptionPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","id":"cd554abc-dc06-4177-be50-ccbc638fd6d9","lists":[{"text":"What You Will Do","content":"<li>Work closely with team lead to deliver product features that enable efficient handling of queries for our internal users (customer service agents) and complaints raised by external users (customer, driver, and merchant)</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems</li><li>Write code that’s clear, concise, performant, tested and easily understood by others</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Writing technical documents and providing technical training for end users if necessary</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2-3+ years of hands-on experience in designing, developing, testing, and deploying applications on Go-Lang, Clojure, Java, Ruby, or OOPL large-scale applications</li><li>In-depth experience&nbsp;of at least one programming language and framework, deep understanding of SQL databases, Linux, Kafka, Redis, and RabbitMQ</li><li>Proficient in OOP, SQL, Design Patterns Data modeling experience in Relational databases</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate risks</li>"}],"text":"Software Engineer - Customer Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9","applyUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><span style=\"font-size: 16px\"><b>About the Team</b></span></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897318094,"descriptionPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><span style=\"font-size: 16px\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"4439eb62-6f08-444b-946d-1dff07d7d0d3","lists":[{"text":"What You Will Do","content":"<li>Working on mobile applications iOS and going forward you will work on flutter application</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, communicate project/development status to internal and external teams in a timely fashion</li><li>Participating in the design review process, seeking and providing constructive criticism</li><li>Improving code structure and architecture in service of testability and maintainability</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentations of how their design and architecture evolves over time</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>2-4 years of experience with iOS development</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in Swift programming, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Understanding of iOS Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third party libraries for networking, async, image loading etc</li><li>Good analytical and problem solving skills</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - iOS ( Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3","applyUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3/apply"},{"additionalPlain":"About the Team\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716980506841,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","id":"930cfb6b-99e3-4334-bc10-3fac18f8eff0","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Helping out in onboarding process by sharing contexts and pairing with new member of the team</li><li>Start mentoring or guiding SE1</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years relevant software development experience through internship stint and/or college projects</li><li>Proficient in Kotlin programming, Java and the Android APIs. </li><li>Strong knowledge in Android Apps architecture and implementationAbility to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular libraries for networking, async, image loading etc.</li><li>Well-versed with Agile methodologies, TDD and Test Engineering and Automation.</li>"}],"text":"Software Engineer (Android) - Gofood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0","applyUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0/apply"},{"additionalPlain":"About the Team\n\nMerchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nOur team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Merchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>Our team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Merchant Lending","allLocations":["Jakarta"]},"createdAt":1721735169268,"descriptionPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","id":"dab778da-b4eb-4e7e-bc8e-997af7210d52","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain user-facing features, translating designs and requirements into well-designed, testable and efficient code</li><li>Collaborate with other team members and stakeholders to deliver high-quality software solutions</li><li>Troubleshooting and debugging to optimize performance.</li><li>Be proactive, ask questions, and be an active member of the team striving towards improving the merchant experience&nbsp;</li><li>Learn new technologies to keep yourself updated and brainstorm with the managers about using the new technologies in day-to-day problem-solving</li>"},{"text":"What You Will Need","content":"<li>Degree/Diploma in Computer Science, Engineering, or related field.</li><li>2+ years of experience in developing using Java</li><li>Understand programming practices such as separation of concerns, unit testing, and writing self-documenting code</li><li>Familiarity with mainstream frameworks like Spring, Spring Boot, and Linux operating systems, understanding of database principles, and proficiency in using databases like MySQL or PostgreSQL.</li><li>Familiarity with front-end related technologies and concepts such as Javascript/Typescript, CSS, HTML, DOM, network protocol, and mainstream front-end frameworks</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (Back End) - Merchant Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52","applyUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713521223842,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"331177df-4294-4bc1-93a4-6459ff18ef97","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97","applyUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899384459,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"c0e92e19-ce60-4cfc-a58b-553f17452483","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483","applyUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483/apply"},{"additionalPlain":"About the Team\n\nConsumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1714016329286,"descriptionPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","id":"88358de8-e37b-4bd6-9afe-359eea3128b9","lists":[{"text":"What You Will Do","content":"<li>Own feature development from end-to-end, constantly pair with junior engineers, and improve them.</li><li>Write code that's clear, concise, performant, tested, and easy to understand by other teams and engineers.</li><li>Contribute to the design and development of highly scalable, available, reliable, secure, and fault-tolerant services.</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices.</li><li>Deep dive and debug production issues across services and levels of the stack when needed.</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently.</li>"},{"text":"What You Will Need","content":"<li>Passion for software development</li><li>At least 3 years of relevant software development experience with consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Ability to learn or use Java, Kotlin, and JS, proficiency in at least one of them</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, database consistency and transactionality, asynchronous programming, fault tolerance and monitoring, performance, feature flags, and backward compatibility&nbsp;</li><li>Understanding of a mobile application’s interaction with the back-end and other systems</li><li>Deep understanding of relational databases; ability to design performant, easy-to-understand architectures, and know-how for applying changes with no downtime to production systems</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, AWS, GCP</li>"}],"text":"Software Engineer (Full Stack) - BNPL","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","descriptionBodyPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9","applyUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9/apply"},{"additionalPlain":" About the team\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div>&nbsp;<span style=\"font-size: 16px\">About the team</span></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899689491,"descriptionPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","id":"89a62415-b145-4593-ac20-b82ec0ccfacb","lists":[{"text":"What You Will Do","content":"<li>Solve technical problems and build the next generation of products for our consumers</li><li>Spike new technologies and find a viable way to improve customers experience</li><li>Improve the testability and maintainability of the code</li><li>Build reusable iOS software components for interfacing with multiple applications</li><li>Improve and stabilize IOS sdks used by number of internal and external clients</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>At Least 2 years of full-time iOS engineering experience</li><li>Experience developing, maintaining, and innovating large scale, consumer mobile application</li><li>Predictability and balance of product delivery speed and quality</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in <b>Swift programming</b>, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Working experience with popular libraries for networking, async, image loading, etc</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><li>Experience and knowledge of writing testable and high-quality code</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (iOS) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","descriptionBodyPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb","applyUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb/apply"},{"additionalPlain":"About the Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</div><div><br></div><div>Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</div><div><br></div><div>As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).</div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1719909295384,"descriptionPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","description":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","id":"1a190954-9482-4953-a750-f2ae33a50003","lists":[{"text":"What You Will Do","content":"<li>Develop and Test: Write, test, and maintain software across our platforms, ensuring robustness and scalability.</li><li>Collaborate: Work closely with senior engineers and cross-functional teams including Backend, Frontend, Mobile, and QA to design and execute solutions.</li><li>Learn and Grow: Receive mentorship from senior engineers, enhancing your understanding of software development processes and best practices.</li><li>Contribute: Play a key role in the development and optimization of new features and systems within Midtrans.</li>"},{"text":"What You Will Need","content":"<li>Currently enrolled in or recently graduated with a degree in Computer Science, Software Engineering, or a related field.</li><li>Strong foundational knowledge in at least one programming language (Java, Python, JavaScript, etc.).</li><li>Understanding of basic software development concepts and methodologies.</li><li>Familiarity with version control systems, preferably Git.</li><li>Problem-Solving: Ability to think critically and solve complex problems.</li><li>Communication: Excellent verbal and written communication skills.</li><li>Teamwork: Eagerness to work within a team-oriented environment.</li><li>Adaptability: Openness to learning new technologies and methodologies.</li>"}],"text":"Software Engineer Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","descriptionBodyPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003","applyUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003/apply"},{"additionalPlain":"About the Team\n\nThe Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">The Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721305380078,"descriptionPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","id":"75c0d634-b28a-4f10-8f5a-efacb32b6444","lists":[{"text":"What You Will Do","content":"<li>Collaborate with product engineers to unify and optimize build standards across Android apps</li><li>Enhance build performance and streamline development processes</li><li>Identify and resolve bottlenecks in the current build system.Forecast and future-proof Android platform engineering services</li><li>Implement best engineering practices and ensure adherence across product groups</li><li>Conduct thorough code reviews and provide constructive feedback</li><li>Mentor junior engineers and support their professional growth</li><li>Participate in architectural design reviews and contribute to technical decision-making</li>"},{"text":"What You Will Need","content":"<li>5+ years of mobile engineering experience with Android as primary expertise</li><li>Proficiency in writing clear, concise, and maintainable code</li><li>Experience with collaborating on projects involving multiple teams</li><li>Strong understanding of mobile app architecture, testing, and performance optimization</li><li>Passion for building scalable and reusable systems</li><li>Ability to make informed decisions in architectural design reviews</li><li>Experience with build systems and CI/CD pipelines</li><li>Familiarity with Flutter or a willingness to learn it</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Sr. Software Engineer (Android) - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444","applyUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444/apply"},{"additionalPlain":"About the Team\n\nOur Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nTransport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)  using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Transport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)&nbsp; using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717676182978,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","id":"22ac4805-bcbe-4698-9e51-cb25754ac244","lists":[{"text":"What You Will Do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Actively mentor SE/ASEs&nbsp; in the team</li><li>Translate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environments</li><li>Improve engineering standards, tooling and processes</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applications</li><li>Have expertise in at least one of Go or Java</li><li>In-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etc</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"Sr. Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244","applyUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks\n\nYou get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks</span></div><div><br></div><div><span style=\"font-size: 16px\">You get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Jakarta"]},"createdAt":1713436041495,"descriptionPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","id":"e2bbb29c-85ef-4db2-9ea7-93af9101b634","lists":[{"text":"What You Will Do","content":"<li>Automate mechanism to make sure app performance adheres to the standards set internally</li><li>Building tools that would alleviate mobile engineer's development experience and productivity&nbsp;</li><li>Build dashboard and alerting system around mobile app performance (using tools like Firebase, Instabug, etc)</li><li>Foster a development culture that focuses on the quality of delivery</li><li>Creating and maintaining SDKs like networking, logging, etc. These sdk’s are responsible for providing common solutions to products across all iOS mobile teams</li><li>Continuously discover, evaluate, and implement new technologies to maximize development efficiency</li><li>Create excellent, clear, and insightful documentation ex: guidelines, best practices, how-to, FAQs etc</li>"},{"text":"What You Will Need","content":"<li>Atleast 3+ years of mobile engineering experience with iOS as primary expertise</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Ability to can take (or pitch) technical decisions, own it and raise impediments early if needed</li><li>You are very well versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>You have a passion for building scalable and composable systems that would last long</li><li>You are a hands-on engineer with a focus on writing easy to read code than over-engineering</li><li>You are a great communicator who can express your ideas clearly and build consensus to push technical agendas</li>"}],"text":"Sr. Software Engineer (iOS) - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634","applyUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634/apply"},{"additionalPlain":"About the Team\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\n\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</span></div><div><br></div><div><span style=\"font-size: 16px\">We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717559195275,"descriptionPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","id":"8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","lists":[{"text":"What You Will Do","content":"<li>Help provide clarity and direction for marketing campaigns or initiatives</li><li>To become the bridge between the Creatives and the marketing, media, social, design, product and research team</li><li>Always bringing the consumer perspective into the creative process in Gojek by simply staying in touch with society and the trends that are changing it</li>"},{"text":"What You Will Need","content":"<li>You have at least 5 years of strategy experience in an agency or related environment</li><li>Ability to deliver a clear, insight-based strategic recommendation in the form of a written brief</li><li>Ability to support Creatives and Designers&nbsp; with relevant stimulus, routes, or advice</li><li>Ability to visualize simple customer journeys in clear &amp; compelling ways</li>"}],"text":"Strategic Planner - Creative Labs - #10088","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px;\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","descriptionBodyPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","applyUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713867338946,"description":"","descriptionPlain":"","id":"afb5bc40-aa4f-4837-a2d9-7d38eade2599","lists":[{"text":"What will you do","content":"<li>Assume ownership of key performance indicators (KPIs) driving revenue and profitability for Consumer Lending <a href=\"http://business.Develop\" class=\"postings-link\">business.</a></li><li><a href=\"http://business.Develop\" class=\"postings-link\">Develop</a> comprehensive strategies and roadmaps to achieve growth objectives through a combination of <a href=\"http://initiatives.Identify\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Identify\" class=\"postings-link\">Identify</a> growth opportunities within the consumer lending business by analyzing business data, transactional data, customer activity within platforms, and leveraging customer <a href=\"http://insights.Lead\" class=\"postings-link\">insights.</a></li><li><a href=\"http://insights.Lead\" class=\"postings-link\">Lead</a> the prioritization process, strategizing, and focusing on solutions aimed at addressing user needs and enhancing user <a href=\"http://experience.Validate\" class=\"postings-link\">experience.</a></li><li><a href=\"http://experience.Validate\" class=\"postings-link\">Validate</a> business strategies and hypotheses through rigorous experimentation and statistical <a href=\"http://methodologies.Present\" class=\"postings-link\">methodologies.</a></li><li><a href=\"http://methodologies.Present\" class=\"postings-link\">Present</a> findings and insights to senior management to inform strategic decision-making regarding feature prioritization and impact <a href=\"http://analysis.Cultivate\" class=\"postings-link\">analysis. </a></li><li><a href=\"http://analysis.Cultivate\" class=\"postings-link\">Cultivate</a> and manage partnerships with external stakeholders.</li>"},{"text":"What will you need","content":"<li>BS/MS in Business, Engineering, Computer Science, Math, Economics, Statistics, or <a href=\"http://equivalent.8-10\" class=\"postings-link\">equivalent.</a></li><li><a href=\"http://equivalent.8-10\" class=\"postings-link\">8-10</a> years of working experience with strong business <a href=\"http://acumen.End\" class=\"postings-link\">acumen.</a></li><li><a href=\"http://acumen.End\" class=\"postings-link\">End</a> to end problem-solving mindset that can work in increments and <a href=\"http://exponents.Strong\" class=\"postings-link\">exponents.</a></li><li><a href=\"http://exponents.Strong\" class=\"postings-link\">Strong</a> project management skills to manage complex projects, also can manage and prioritize multiple internal and external <a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">Proficiency</a> in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with good knowledge of SQL and experimentation processHustle is essential, moving quickly and executing to allow for continual iteration is a core competency of the teamExperience in a financial services and technology companies is preferred.</li>"}],"text":"Strategy Senior Manager, Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599","applyUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599/apply"},{"additionalPlain":"Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1709264557847,"descriptionPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","description":"<div><span style=\"font-size: 10pt\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","id":"eaab5bee-084d-4cdc-bd08-63230251009c","lists":[{"text":"What you will do","content":"<li>Develop and maintain supply related dashboards to monitor key metrics and compare achievements against targeted <a href=\"http://goals.Analyze\" class=\"postings-link\">goals.</a></li><li><a href=\"http://goals.Analyze\" class=\"postings-link\">Analyze</a> various data points, detect anomalies and spot trends to drive business and strategic decision-making on supply <a href=\"http://initiatives.Collaborate\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Collaborate\" class=\"postings-link\">Collaborate</a> with the BI, Data Science, Marketing, and Product Management teams to ensure alignment on data analysis, methodologies, insights, and recommendations and proactively escalate issues to relevant <a href=\"http://stakeholders.Analysis\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Analysis\" class=\"postings-link\">Analysis</a> on the competitive intelligence insights and <a href=\"http://findings.Be\" class=\"postings-link\">findings.</a></li><li><a href=\"http://findings.Be\" class=\"postings-link\">Be</a> the go-to person on anything related to the supply health metrics and analysis.</li><div><br></div>"},{"text":"What you will need","content":"<li>A BS/MS in Business, Engineering, Computer Science, Mathematics, Economics or equivalent experience</li><li>3+ years of experience within one or more of the following fields: Business Analytics, Strategy and Planning, Growth or relevant functions</li><li>Comfortable analyzing large amounts of raw data with an obsession to detail and accuracy of data</li><li>Able to uncover the story and relationship behind the numbers and communicate the insights to a wider audience</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Proficiency in multiple analytic, database, and visualization tools (e.g., Tableau, Looker Studio, etc.) along with strong knowledge of SQL</li><li>A scientific and hypothesis-driven thinking process with the ability to work in increments and exponents</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders </li><div><br></div>"}],"text":"Supply Strategy Data Analyst [Ads]","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","descriptionBodyPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c","applyUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c/apply"},{"additionalPlain":"About the team \n\nWe are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.\n\n","additional":"<div><b>About the team</b>&nbsp;</div><div><br></div><div>We are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - ESG","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721114762245,"descriptionPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","id":"1a303596-73f9-4d05-85f9-73cd361f03ef","lists":[{"text":"What you will do","content":"<li>Leading GoTo Group’s sustainability commitments and related workstreams, focusing on the company's environmental and socio-economic impact and financial inclusion of the ecosystem.</li><li>Overseeing Zero Barriers as a socio-economic pillar, focusing on the development of in-house financial products and services aimed at improving the economic well-being and sustainable livelihoods of GoTo’s drivers and merchant partners.</li><li>Implementing impact measurement frameworks to transparently communicate social and economic benefits resulting from company initiatives, reinforcing accountability.&nbsp;</li><li>Driving the implementation of comprehensive Diversity, Equity, and Inclusion (DEI) policies within GoTo, to foster a culture of equality and respect organization-wide.&nbsp;</li><li>Ensuring proactive compliance with relevant environmental, social, and governance (ESG) regulations, surpassing standards to uphold ethical business practices.</li>"},{"text":"What you will need","content":"<li>Extensive experience in ESG strategy, preferably within the tech industry.&nbsp;Strong understanding of global and local sustainability regulations and standards. (GRI, POJK, MSCI, S&amp;P, etc.)</li><li>Proven track record in leading sustainability initiatives and integrating them into business operations.</li><li>Excellent stakeholder management and communication skills.&nbsp;</li><li>Ability to analyze complex data and translate it into actionable strategies.&nbsp;Innovative thinking and problem-solving abilities.&nbsp;</li><li>Leadership skills with the ability to drive cultural change and motivate teams.&nbsp;</li><li>Proficiency in project management and sustainability reporting tools.</li>"}],"text":"Sustainability Senior Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef","applyUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720377852482,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically-oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.</li>"}],"text":"Technical Program Manager - Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","applyUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720689871979,"descriptionPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","id":"bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Support Head in establishing and strengthening relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors</li><li>Project Leadership: Support multiple projects in partnership with government institutions, focusing on Transport and Mobility technology.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances</li><li>Project Management: Support public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government</li><li>Established network among government stakeholder with a proven impact on policy decisions</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Transport and Mobility PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","descriptionBodyPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","applyUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705901801143,"descriptionPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","description":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","id":"17408b81-f5a0-4f15-afae-cc04ed7e43b6","lists":[{"text":"What You Will Do","content":"<li>Prepare Risk reporting and position reporting</li><li>Conduct assessments to define and analyze possible risks</li><li>Evaluate the gravity of each risk by considering its consequences</li><li>Design processes to eliminate or mitigate potential risks</li><li>Evaluate existing policies and procedures to find weaknesses</li><li>Prepare reports and present recommendations</li><li>Ensure risk exposures of the company is within stipulated limits</li><li>Work closely with other business stakeholders</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years&nbsp;</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal and external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL will be an advantage</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Underwriting and Credit Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","descriptionBodyPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6","applyUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6/apply"},{"additionalPlain":"About The Team\nMerchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Merchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721636128423,"descriptionPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","id":"a007af4b-690d-4487-874d-f04ce3f62ce0","lists":[{"text":"What You Will Do","content":"<li>Maintain relationship with BPO vendor and regularly evaluate their productivity&nbsp;</li><li>Become a COE of merchant engagement framework for region team</li><li>Assisting SM Merchant Engagement in managing milestones, timeline, as well the stakeholders engagement related to the managed projects.</li><li>Develop and updating Key Insights and Analysis related to Unmanaged merchants performances</li>"},{"text":"What This Role Needs","content":"<li>At least 2 years experience in field sales or telemarketing, especially with a proven track record of managing local / regional business in reputable companies</li><li>Experienced in managing large business partner such as distributor or outsourcing vendor</li><li>Have experience in basic to intermediate data analytics skills</li><li>Having ability to turn insight into actionable plan</li><li>Strong business acumen with proven track record in stakeholder management</li>"}],"text":"Unmanaged Merchant Engagement Senior Associate - #10326","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","descriptionBodyPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0","applyUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119556899,"descriptionPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","id":"147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","lists":[{"text":"What you will do","content":"<li>Own the GoMart Growth Strategy and Promotion budgetTake charge of monthly budgeting and weekly execution with an emphasis on growth while maintaining profitability</li><li>Lead initiatives, strategies, and implementation, with a primary focus on the customer lifecycle funnel targeting the acquisition of new and churned users while growing retention of existing customers through a compelling offer.</li><li>Experiment with a combination of multiple initiatives (e.g. vouchers/promotion, product or pricing changes) to validate initiatives through statistical analysis</li><li>Use data across customer, driver, and merchant activity from multiple products to hypothesize potential solutions and test them in practice&nbsp;</li><li>Collaborate with Merchandising, Marketing, Product, and Operations teams in the development and implementation of initiatives and strategies</li><li>Prepare routine reports and present findings to leadership as the basis of rationale and recommendations for strategic decision-making</li>"},{"text":"What you will need","content":"<li>At least 5 years of experience in strategy or growth role at a tech company, e-commerce, or management consulting background</li><li>Strong proficiency in Microsoft Excel; Understanding of SQL and other statistical tools is a must.</li><li>Strong business acumen, an end-to-end problem-solving mindset with the ability to work in increments and exponents and balance attention to detail with swift execution</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"User Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","applyUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663/apply"}]
+  recorded_at: Tue, 30 Jul 2024 16:27:57 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.gotocompany.com/"]}],"limit":1}'
@@ -109,9 +109,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Thu, 27 Jun 2024 13:37:14 GMT
+      - Tue, 30 Jul 2024 16:27:58 GMT
       Etag:
-      - W/"1719495434288"
+      - W/"1722356878488"
       Server:
       - openresty
       X-Cb-Engine:
@@ -123,11 +123,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '6'
+      - '5'
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '12'
+      - '14'
       Content-Length:
       - '525'
       Connection:
@@ -138,6 +138,6 @@ http_interactions:
         Group","identifier":{"permalink":"goto-group","image_id":"pioqotgm6efdzbjvkirg","uuid":"0f2e5ecc-d44c-49c0-9e36-7a117fb1eedc","entity_def_id":"organization","value":"GoTo
         Group"},"linkedin":{"value":"https://www.linkedin.com/company/gotogroup"},"short_description":"GoTo
         Group offers a digital ecosystem for on-demand services, e-commerce, fintech,
-        and logistics.","rank_org":3380,"website_url":"https://www.gotocompany.com"}}]}'
-  recorded_at: Thu, 27 Jun 2024 13:37:14 GMT
+        and logistics.","rank_org":4989,"website_url":"https://www.gotocompany.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:27:58 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_manatal.yml b/spec/fixtures/cassettes/create_company_manatal.yml
index ad6ca49e..de27aa21 100644
--- a/spec/fixtures/cassettes/create_company_manatal.yml
+++ b/spec/fixtures/cassettes/create_company_manatal.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:15 GMT
+      - Tue, 30 Jul 2024 16:27:59 GMT
       Content-Type:
       - application/json
       Content-Length:
@@ -44,7 +44,7 @@ http_interactions:
     body:
       encoding: UTF-8
       string: '{"name":"PTC Group","logo":"https://manatal-backend-public-assets.s3.amazonaws.com/media/career_portal_logo_direct_upload/17de54dc-a64e-4285-8a80-c6896d54cdef_logotipo_PTCGROUP_crv_14092016-3.png","website":"https://ptcgroup.global/","description":"","facebook_url":"https://www.facebook.com/ptcgroup.global","linkedin_url":"https://www.linkedin.com/company/ptcgroup/","is_organizations_visible":false,"is_job_listing_enabled":true}'
-  recorded_at: Thu, 27 Jun 2024 13:37:15 GMT
+  recorded_at: Tue, 30 Jul 2024 16:27:59 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/
@@ -64,11 +64,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 27 Jun 2024 13:37:16 GMT
+      - Tue, 30 Jul 2024 16:27:59 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '26376'
+      - '19729'
       Connection:
       - keep-alive
       Server:
@@ -89,11 +89,11 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":250,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1655161,"hash":"QV7XRV36","position_name":"Administrador Redes & Sistemas","description":"<p>O nosso cliente é um Tier1 do setor automotivo.</p>\n<p>Administrador de Sistemas e Redes</p>\n<p><strong>RESPONSABILIDADES:</strong></p>\n<ul><li>Gerir a instalação e manutenção de equipamentos de IT (estações de trabalho / telefones / dispositivos de rede / realização de masters ...), garantir a monitorização do parque informático e sua atualização.</li><li>Ser o principal suporte aos utilizadores (N1 a N3) na gestão de questões de IT (ticketing, relatórios de incidentes, elaboração de procedimentos, gestão de backups...)</li><li>Garantir o suporte da infraestrutura de rede (switch, servidores ESX, firewall, Active Directory...) e o gestão do VM Data center</li><li>Supervisionar os sites para a melhoria, fiabilidade e otimização dos equipamentos de IT da divisão.</li><li>Ser o suporte dos correspondentes de IT de cada fábrica;</li></ul>\n<p><strong>REQUISITOS:</strong></p>\n<ul><li>Formação superior em informática ou equivalente;</li><li>Mínimo de 5 anos de experiência no setor industrial em posição semelhante;</li><li>Fluência no inglês (obrigatório).</li></ul>\n<p><strong>Competências técnicas</strong>:</p>\n<ul><li>Redes LAN, WAN, VLAN, Active Directory, DNS, DHCP;</li><li>Supervisão NAGIOS;</li><li>Windows Server 2008 - 2016;</li><li>VMware, Veeam;</li><li>Kaspersky.</li></ul>\n<p><strong>Soft skills:</strong></p>\n<ul><li>Autonomia;</li><li>Rigor;</li><li>Criatividade;</li><li>Comprometimento;</li><li>Apetência para o trabalho em equipa;</li><li>Deverá ter disponibilidade para deslocações entre as várias fábricas do grupo sempre que necessário.</li></ul>","country":"Portugal","state":"Aveiro District","city":"Estarreja","address":"","zipcode":"","location_display":"Estarreja, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1709699,"hash":"QX7X84XR","position_name":"Administrativo/a de contabilidade","description":"<p>A nossa empresa cliente é uma marca de luxo dedicada à venda de produtos de alta qualidade. Procura para integrar a sua equipa um/a:</p>\n<p><strong>Administrativo/a de contabilidade:</strong></p>\n<p><strong>Tarefas a desempenhar:</strong></p>\n<p>- Auxiliar em tarefas administrativas, como gestão de arquivos, preparação de documentos diversos de apoio à contabilidade;</p>\n<p>- Fazer a reconciliação bancária;</p>\n<p>-&nbsp;Organizar todos os documentos a serem enviados ao contabilista, por exemplo. a preparação de folhas de caixa e mapas de custos;</p>\n<p>-&nbsp;Registo e processamento de transações financeiras (compras, contas, tickets, pagamentos e recebimentos);</p>\n<p>-&nbsp;Manter registros precisos, organizar documentos e garantir a conformidade com as políticas e procedimentos da empresa;</p>\n<p>-&nbsp;Inserção de dados financeiros em softwares de contabilidade (ERP PHC) e no excel, mantendo registos atualizados e precisos;</p>\n<p>-&nbsp;Apoia a previsão e análise de custos e proveitos;</p>\n<p>-&nbsp;Apoio em projetos de incentivo do estado (gestão de candidaturas, organização de pagamentos e documentos solicitados);</p>\n<p>- Auxilio nas cobranças a clientes.</p>\n<p><strong>Requisitos:&nbsp;</strong></p>\n<p>- Experiência de pelo menos 2 anos em funções similares;</p>\n<p>- Excelentes conhecimentos de informática em MS Office;</p>\n<p>- Ótima análise/interpretação de informações e resultados de relatórios financeiros (conhecimento de normas e procedimentos contabilísticos);</p>\n<p>- Capacidade analítica/crítica e foco nos resultados, habilidades de resolução de problemas;</p>\n<p>- Organizado/disciplinado e orientado a resultados e cumprimento de prazos;</p>\n<p>- Bons conhecimentos de Inglês (obrigatório);</p>\n<p>- Capacidade de realizar múltiplas tarefas;</p>\n<p>- Ótimas habilidades interpessoais (team player) e de comunicação.</p>\n<p>- Habilidade crítica:</p>\n<p><strong>﻿﻿Oferecemos:<br></strong></p>\n<p><strong>﻿</strong>- Integração numa empresa de marca de luxo;<br></p>\n<p>﻿- Remuneração compatível com experiência demonstrada.<br></p>\n<p><strong><br></strong></p>\n<p><br></p>","country":"Portugal","state":"Porto District","city":"Porto","address":"","zipcode":"","location_display":"Porto, Porto District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1802273,"hash":"QVX3V5R8","position_name":"Analista AWS","description":"<p><strong>Cargo: Analista AWS</strong></p>\n<p>3-5 anos de experiência em:</p>\n<p>Migrar ambientes on-premises e  ambientes em outras nuvens para a nuvem AWS</p>\n<p>Arquitetar, projetar e implementar projetos de soluções de Nuvem Híbrida, com forte conhecimento em áreas de infraestrutura, envolvendo Armazenamento, Servidores, Rede, etc.</p>\n<p><strong>Habilidades em:</strong></p>\n<p>Orientar clientes na implementação de soluções de nuvem na AWS e experiência na implementação de serviços na AWS como EC2, EBS, S3 e RDS.</p>\n<p>Automatizar tarefas ou trabalhos que exigem intervenção repetitiva</p>\n<p>Interagir com clientes para realizar trabalhos com equipes técnicas</p>\n<p></p>\n<p><strong>Qualificações Desejáveis:</strong></p>\n<p><strong>Hard skills:</strong></p>\n<p>  Nível avançado de inglês</p>\n<p>  Espanhol avançado</p>\n<p>  Certificação AWS Solutions</p>\n<p>  Manutenção de ambientes on-premise</p>\n<ul><li>Experiência em migrar sistemas legados para a nuvem e implementar as melhores práticas de segurança para clientes AWS</li><li>Experiência com outras soluções de computação, como ECS, EKS, AppRunner e ElasticBeanstalk</li><li>Experiência com soluções de rede como Transit Gateway, PrivateLink, Direct Connect e CloudFront</li><li>Experiência em automação através de scripts (Infraestrutura como Código - Terraform/CloudFormation/Ansible)</li><li>Experiência com o processo de migração em nuvem no modelo AWS (OLA e MAP), incluindo Assessment, Mobilize e Migration</li><li>Experiência com ferramentas de avaliação de ambiente de nuvem (TSO Logic, Migration Evaluator, Cloudamize, Cloudscape)</li><li>Experiência em gerar Casos de Negócios a partir dos dados coletados, com TCO/Calculator/Migration Waves Ferramentas de migração de ambientes AWS (Migration Hub, DMS, CloudEndure, MGM, etc.)</li><li>Experiência em projetar arquitetura de rede e aplicação em ambientes AWS, nuvem híbrida e multi-nuvem</li></ul>\n<p></p>\n<p>Soft Skills:</p>\n<ol><li>Senso Crítico: Habilidade para avaliar situações complexas, identificar problemas, questionar informações e propor soluções eficazes. Pensamento lógico e objetivo para tomar decisões bem fundamentadas.</li><li>Proatividade: Iniciativa e Antecipação. Identificar oportunidades e desafios antes que eles surjam e tomar medidas preventivas. Inclui a capacidade de agir de maneira independente e proativa, propondo melhorias e soluções sem esperar por instruções específicas.</li><li>Habilidade de Trabalhar em Equipe e Buscar Orientação: Capacidade de colaborar efetivamente com colegas de equipe e superiores, reconhecendo quando é necessário pedir ajuda ou orientação.</li><li>Independência: Autogestão e organização. Trabalhar de forma independente, gerenciar o próprio tempo e tomar decisões sem a necessidade de supervisão constante.</li><li>Acabativa: Determinação e Conclusão. Habilidade para levar tarefas e projetos até a conclusão com alta qualidade. Envolve atenção aos detalhes, perseverança para superar obstáculos e compromisso com a entrega de resultados consistentes e de excelência.</li><li>Prontidão: Rapidez e Eficiência. Capacidade de responder rapidamente a solicitações, mudanças e emergências. Inclui a habilidade de adaptar-se rapidamente às novas circunstâncias, mantendo a eficácia e a qualidade do trabalho realizado.</li><li>Comunicação Interpessoal com Clientes: Capacidade de interagir com clientes de maneira clara, profissional e empática, garantindo que suas necessidades sejam compreendidas e atendidas.</li></ol><p></p>\n<p>﻿- Modelo de trabalho:&nbsp;Remoto</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1544020,"hash":"L68X68RR","position_name":"ANALISTA -  BIW","description":"<p></p><p>Junte-se a nós para fazer parte da equipe na área de<strong> BIW (Body in White)</strong>! Estamos em busca de talentos para oportunidades emocionantes, como <strong>Project Chief&nbsp;</strong>e <strong>Projetista.</strong></p>\n<p>Se você procura desafios estimulantes e deseja contribuir para o desenvolvimento de soluções inovadoras, não perca esta chance única - aplique agora mesmo e compartilhe conosco o seu currículo! Valorizamos a diversidade e estamos ansiosos para receber candidaturas de profissionais comprometidos e apaixonados pela excelência. Venha fazer a diferença conosco!</p><p> </p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1688360,"hash":"LRW396XX","position_name":"Analista de Comércio Exterior Pleno","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\" _msttexthash=\"1135381\" _msthash=\"848\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p _msttexthash=\"1748799\" _msthash=\"731\">\n<font _mstmutation=\"1\" _msttexthash=\"104397202\" _msthash=\"849\">O Analista de Comércio Exterior Pleno no segmento, desempenha um papel fundamental na gestão e coordenação das operações de importação e exportação específicas desse setor altamente especializado. Este profissional atua na interface entre as empresas do ramo  e os mercados internacionais, garantindo o cumprimento das regulamentações específicas e a eficiência das operações comerciais. Responsável em Elaborar e revisar documentos</font><br><font _mstmutation=\"1\" _msttexthash=\"22406800\" _msthash=\"850\">Prestar suporte e orientação técnica aos demais membros da equipe, compartilhando conhecimentos específicos do segmento. Competências para atuar com Trading, inclusive captação de novos clientes.</font></p>\n<p _msttexthash=\"1042899\" _msthash=\"730\"><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n<font _mstmutation=\"1\" _msttexthash=\"4936503\" _msthash=\"851\">Experiência atuando na área de comércio exterior, preferencialmente em cargos similares.</font><br><font _mstmutation=\"1\" _msttexthash=\"5897619\" _msthash=\"852\">\tDomínio dos processos de importação e exportação, incluindo a legislação tributária e cambial.</font><br><font _mstmutation=\"1\" _msttexthash=\"4369846\" _msthash=\"853\">\tHabilidade analítica para interpretar dados e tendências do mercado internacional.</font><br><font _mstmutation=\"1\" _msttexthash=\"6191926\" _msthash=\"854\">\tConhecimento em ferramentas de gestão e sistemas informatizados relacionados ao comércio exterior.</font><br><font _mstmutation=\"1\" _msttexthash=\"7133230\" _msthash=\"855\">\tOrganização, proatividade e habilidade para trabalhar sob pressão em um ambiente dinâmico e multifuncional.</font><br><font _mstmutation=\"1\" _msttexthash=\"20220343\" _msthash=\"856\">\tCoordenar o processo de importação e exportação, desde a negociação dos contratos até a entrega final dos produtos, garantindo o cumprimento dos prazos e regulamentações governamentais.</font><br><font _mstmutation=\"1\" _msttexthash=\"13677690\" _msthash=\"857\">\tManter-se atualizado sobre as mudanças nas políticas comerciais e aduaneiras, interpretando e aplicando corretamente as leis e regulamentos pertinentes.</font><br><font _mstmutation=\"1\" _msttexthash=\"14534845\" _msthash=\"858\">\tColaborar com outras áreas da empresa, como financeiro, compras e produção, para garantir a integração e sincronia das operações comerciais internacionais.</font><br><font _mstmutation=\"1\" _msttexthash=\"11398205\" _msthash=\"859\">\tConhecimento sólido das regulamentações sanitárias, fitossanitárias e aduaneiras específicas para o comércio dos produtos do segmento</font><br><font _mstmutation=\"1\" _msttexthash=\"5211544\" _msthash=\"860\">\tHabilidade para trabalhar com análise de dados e interpretação de normas técnicas do setor.</font><br><font _mstmutation=\"1\" _msttexthash=\"11871288\" _msthash=\"861\">\tCapacidade de comunicação e negociação em português e inglês, com preferência por conhecimentos em outros idiomas relevantes para o segmento.</font><br><font _mstmutation=\"1\" _msttexthash=\"5360576\" _msthash=\"862\">\tDomínio de ferramentas de gestão e sistemas informatizados utilizados no comércio exterior.</font><br><font _mstmutation=\"1\" _msttexthash=\"117845\" _msthash=\"863\">\tProativo</font></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"1107301\" _msthash=\"729\"><strong _mstmutation=\"1\"><strong></strong></strong></font><font _mstmutation=\"1\" _msttexthash=\"187629\" _msthash=\"865\"><font _mstmutation=\"1\" _msttexthash=\"198744\" _msthash=\"867\">Entre 2 a 5 anos-&nbsp;</font></font><strong><strong _msttexthash=\"262860\" _msthash=\"866\">&nbsp;Ensino Superior</strong></strong></p>\n<p _msttexthash=\"615355\" _msthash=\"728\"><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"Pinheiros","address":"","zipcode":"","location_display":"Pinheiros, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1698635,"hash":"L9V5Y99Y","position_name":"Analista de Contas a Pagar e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Pagar e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p><br>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.<br>﻿<br>﻿<strong><br>﻿Responsabilidades:</strong></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Pagar do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p>\n<ul><li>Lançamento de faturas de despesas gerais</li><li>Contabilização de faturas de compra de peças e posterior gestão de estoque</li><li>Verificação de preços na plataforma do cliente</li><li>Contabilização de faturas de ativos fixos</li><li>Lançamento de faturas FI (Débito Direto)</li><li>Gestão de contas FAR (Bens recebidos/Faturas não recebidas)</li><li>Gestão de reclamações de fornecedores</li><li>Colaboração na revisão de propostas de pagamento</li><li>Correções de fatura</li><li>Controlo da SII</li></ul>\n<p><br>﻿<strong><br>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional:&nbsp;2 a 3 anos na área.&nbsp;</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1802257,"hash":"L7649R8X","position_name":"Analista de CRM e Dados","description":"<p>Estamos em busca de um <strong>Analista de CRM e Dados</strong> para integrar o time de um de nossos clientes que atua no ramo de Energias.</p>\n<p><strong>Responsabilidades e Tarefas da Função</strong></p>\n<p>﻿﻿Owner da esteira de dashboards e relatórios da equipe e implementação de projetos de performance e gestão de clientes, com interface ativa com áreas/projetos de TI, Inteligência de Mercado e Comercial, Produtos, MKT, experiência do cliente, integração de sistemas e dados, contemplando toda a jornada do cliente dentro da cia.﻿</p>\n<p>Entender o cenário AS IS do mercado de energia e capturar oportunidades de melhorias (cenário TO BE) através de projetos relacionados a CRM, ecossistema digital e experiência do cliente, relacionados à abertura do mercado de energia.<br>\n﻿<br>\nOwner da esteira de relatórios e dashboards da equipe, incluindo a manipulação de dados em diferentes bases e a visualização em PowerBI.<br>\n﻿<br>\nAtender às demandas de evolução de CRM visando aumentar conversão de vendas, reduzir trabalho operacional, aumentar tempo de permanência do cliente na base bem como prevenir churn, atuando em diversas fases do funil de MKT e Vendas.<br>\n﻿<br>\nMonitorar a qualidade e manter a integridade das bases da comercializadora, trabalhando junto com as equipes de pós vendas, vendas, marketing e TI.<br>\n﻿<br>\nParticipar da priorização do roadmap/esteira de implementação de iniciativas de negócio que enderecem as dores dos clientes e áreas de negócio da companhia.<br>\n﻿<br>\nImplementar e acompanhar projetos de performance de clientes como contagem e classificação de clientes, NPS e Healthscore de clientes.<br>\n﻿<br>\nAnalisar detalhadamente relatórios de campanhas e dashboards de performance de vendas.<br>\n﻿<br>\nTrabalhar com fornecedores externos e parceiros para enriquecer os processos atuais e TO BE.</p>\n<p></p>\n<p><strong>Requisitos Obrigatórios﻿</strong></p>\n<ul>\n<li>Expert em dashboards e relatórios (PowerBI, dashs SalesForce e excel); conhecimento intermediário de SalesForce (perfil usuário: SalesCloud, MKT Cloud e ServiceCloud);</li>\n<li>Bacharelado em Estatística, Matemática, Economia, Ciência da Computação ou área relacionada.</li>\n<li>Bom conhecimento com CRM</li>\n<li>Experiência em análise de inteligência comercial, com foco específico em performance de vendas e operações.</li>\n<li>Excelentes habilidades analíticas e capacidade de traduzir dados complexos em insights palpáveis.</li>\n<li>Fortes habilidades de comunicação verbal e escrita, com capacidade de apresentar resultados de forma clara e persuasiva.</li>\n<li>Orientação para resultados, capacidade de trabalhar de forma independente e gerenciar múltiplas prioridades em um ambiente dinâmico.</li>\n<li>Problem Solving: soluções para problemas complexos e análise de cenários anteriores para aprendizado e tomada de decisões;</li>\n<li>Conhecimento em desenho de processo e mapeamento de melhorias operacionais;</li>\n<li>Manipulação de dados para geração de insights;</li>\n<li>Visão Tech.</li>\n</ul>\n<p><strong>Diferencial</strong></p>\n<ul>\n<li>Experiência prévia nos mercados de energia, telecom ou financeiro; conhecimento intermediário de arquitetura de sistemas e billing.</li>\n<li>Cursos de PowerBI, Salesforce e CRM desejáveis.</li>\n</ul>\n<p><strong>Informações Adicionais </strong></p>\n<ul>\n<li>Contratação: ﻿CLT </li>\n<li>Modelo de Trabalho: Híbrido - 3 dias presenciais em São Paulo. </li>\n</ul>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Thu, 27 Jun 2024 13:37:16 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1930649,"hash":"QVXR6YY8","position_name":"Accounts Analyst - Receivable/Payable (fluent in Swedish)","description":"<p><strong>Position: Accounts Analyst - Receivable/Payable&nbsp;(fluent in Swedish)</strong></p>\n<p><strong>Location: Aveiro, Portugal</strong></p>\n<p><br></p>\n<p>Our client is a global innovation and solutions partner, manufacturing low-emission and alternative fuel power needs. Their mission is to provide next-generation powertrain solutions as markets around the world transition to a more sustainable future.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsibilities:</strong></p>\n<p>This person will report to the Head of Accounting and will support the Accounts Receivable and/or Accounts Payable areas of our client. It is estimated that around 3,500 to 4,000 invoices will be processed each month.</p>\n<ul><li>Issuing and posting invoices for sales and general expenses</li><li>Accounting for receipts, invoices for parts purchases, and invoices for fixed assets</li><li>Bank reconciliation</li><li>Checking prices and receipts on the customer platform</li><li>Managing accounts receivable (customers and invoices) and FAR accounts (goods received/invoices not received)</li><li>Monitoring due dates and collections</li><li>Default management and negotiation with clients</li><li>Managing supplier complaints</li><li>Collaboration in reviewing credit and payment proposals</li><li>Invoice and invoice corrections</li><li>Control of receipts, generation of financial reports and IBS control</li><li>Customer service and resolving issues related to invoices and payments</li></ul>\n<p><strong><br></strong></p>\n<p><strong>﻿Requirements:</strong></p>\n<ul><li>Degree in Business Administration and Management, Economics or Business Sciences, or similar field;</li><li>Professional experience: 2 to 3 years in the field.</li><li>Languages: fluent English and Swedish required (regular communication with foreign countries); Spanish and/or Portuguese valuable.</li><li>Experience in SAP and Excel.</li><li>Be available to work in Portugal.﻿</li></ul>","country":"Sweden","state":"","city":"Stockholm","address":"","zipcode":"","location_display":"Stockholm, Sweden","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965495,"hash":"L96W5744","position_name":"AGCO - Almoxarife (reposição)","description":"<p>Almoxarife, com certificação em NR11, para atuar presencialmente em Mogi das Cruzes, horário administrativo&nbsp;</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938459,"hash":"L96575V4","position_name":"AI & Computer Vision Developer","description":"<p><strong>Posição: AI &amp; Computer Vision Developer</strong><br></p>\n<p><strong></strong><strong>Localização: Guimarães (híbrido)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma empresa especialista em visão artificial, integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a <strong>automatização de processos</strong>.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p></p>\n<ul>\n <li>Aplicar técnicas em visão computacional e inteligência      artificial para construção de algoritmos e sistemas inteligentes para      aplicação nos projetos e produtos do cliente.</li>\n <li>Desenvolver software para aplicações em grande escala.</li>\n <li>Disposição para trabalhar num ambiente dinâmico e flexível.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul>\n <li>BS,      MS ou Ph.D. licenciatura em Ciência da Computação, Engenharia ou área      relacionada.</li>\n <li>+2      anos de experiência numa das seguintes áreas: visão computacional,      inteligência artificial, sistemas informáticos.</li>\n <li>Experiência      em programação em C / C++ e QT.</li>\n <li>Experiência com Halcon, OpenCV ou outra ferramenta especializada em      computer vision.</li><li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933733,"hash":"L763WY85","position_name":"Analista de Custos(ferramental)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos&nbsp;qualificado e experiente para atuar na área de ferramental de injeção plástica.</p>\n<h3>Requisitos</h3>\n<ul><li>Conhecimento avançado em ferramental de injeção plástica, incluindo os custos envolvidos na produção, manutenção e reparo das ferramentas.</li><li>Habilidades mestras em tecnologia periférica de ferramental de injeção, tais como sistemas de câmera quente, válvulas sequenciais, acionamentos hidráulicos ou pneumáticos, entre outros.</li><li>Leitura e escrita técnica em língua inglesa, para comunicação com fornecedores e clientes internacionais.</li><li>Experiência em atividades relacionadas ao ferramental de injeção plástica, tais como:</li><li>Try outs: realização de testes de moldagem com as ferramentas, verificando a qualidade e a conformidade dos produtos.</li><li>Liberação de ferramental: emissão de relatórios e documentos que atestam a aptidão das ferramentas para a produção.</li><li>Inspeção / desenvolvimento de ferramentas Soft e Hard: avaliação e aprimoramento das características técnicas e funcionais das ferramentas, tanto em estágio inicial (Soft) quanto em estágio final (Hard).</li><li>Aprovação de texturização: análise e validação da textura aplicada nas superfícies das ferramentas, de acordo com as especificações do cliente.</li><li>Validação dimensional: medição e verificação das dimensões das ferramentas e dos produtos, utilizando instrumentos de precisão e seguindo os padrões de tolerância.</li><li>Modificação de produto: execução de alterações nas ferramentas, conforme solicitação do cliente ou necessidade de melhoria do produto.</li><li>Auditorias de ferramental em injetores parceiros: inspeção e controle da qualidade das ferramentas utilizadas por empresas terceirizadas que prestam serviços de injeção plástica.</li><li>Acompanhamento de FMEA: participação na análise de modos de falha e seus efeitos, identificando e prevenindo possíveis problemas nas ferramentas e nos produtos.</li><li>Acompanhamento de testes de Moldflow: supervisão e interpretação dos resultados dos testes de simulação computacional do processo de injeção plástica, otimizando o desempenho das ferramentas.</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933713,"hash":"QVXRYW7R","position_name":"Analista de Custos(plásticos)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos com experiência e conhecimento avançado em materiais de injeção, aplicações, propriedades, testes, validação, desenvolvimento de fornecedores, modificações de produto, auditorias e propostas de VAVE.</p>\n<h4><strong>Requisitos</strong></h4>\n<ul><li>Formação superior em Engenharia de custos, Química ou áreas afins.</li><li>Conhecimento avançado em polímeros de engenharia, incluindo os custos envolvidos na sua aplicação.</li><li>Conhecimento avançado em aplicações de polímeros, incluindo os custos envolvidos na sua seleção, especificação e substituição.</li><li>Habilidades de mestre em propriedades de materiais de injeção, incluindo os custos envolvidos na sua otimização, controle e melhoria.</li><li>Habilidades de mestre para resolver problemas de polímeros no processo de injeção, incluindo os custos envolvidos na sua prevenção, detecção e correção.</li><li>Leitura, escrita e fala técnica em inglês, com capacidade de se comunicar com clientes, fornecedores e equipes internacionais.</li><li>Capaz de realizar mudanças de material e análise de fornecedores, incluindo os custos envolvidos na sua avaliação, negociação e homologação.</li><li>Habilidades de mestre em propostas de VAVE (Value Analysis and Value Engineering), incluindo os custos envolvidos na sua elaboração, apresentação e implementação.</li><li>Experiência em:</li><li>Testes de materiais, incluindo ensaios mecânicos, térmicos, ópticos, químicos e ambientais.</li><li>Validação de materiais, incluindo aprovação de cores (padrão), validação dimensional, análise de falhas e emissão de relatórios.</li><li>Desenvolvimento de fornecedores, incluindo pesquisa de mercado, prospecção, qualificação, auditoria e acompanhamento.</li><li>Modificação de produto, incluindo alterações de design, funcionalidade, desempenho e qualidade.</li><li>Auditorias de materiais em parceiros injetores, incluindo verificação de conformidade, rastreabilidade, controle de estoque e gestão de resíduos.</li><li>FMEA (Failure Mode and Effect Analysis) e acompanhamento de Moldflow (simulação de injeção).</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852358,"hash":"L8657W63","position_name":"Analista de Dados","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><li><strong>Gênero:</strong> Mulher</li><li><strong>Habilidades:</strong><ul><li>Excelente conhecimento em Excel</li><li>Iniciativa</li><li>Conhecimento intermediário ou bom em Power BI</li></ul>\n<p></p>\n<p></p></li><li><strong>Formação:</strong> Técnica</li><li><strong>Idioma:</strong> Inglês</li><li><strong>Regime de Trabalho:</strong> Hibrido / Betim</li><li><br></li><p></p>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1928936,"hash":"LR4367RX","position_name":"Analista de Dados","description":"<p><strong>Responsabilidades:</strong></p>\n<ul><li>Gerenciar o orçamento designado para projetos de engenharia, garantindo o uso eficiente dos recursos financeiros disponíveis.</li><li>Monitorar e otimizar a distribuição de trabalho entre as diferentes áreas de engenharia, assegurando a eficácia operacional e o cumprimento dos prazos.</li><li>Colaborar com as equipes de projeto para identificar áreas de melhoria e implementar soluções eficazes para aumentar a eficiência e a produtividade.</li><li>Comunicar-se de forma eficaz com diversas interfaces, incluindo equipes de engenharia, líderes de projeto e stakeholders, para alinhar expectativas e garantir o progresso consistente dos projetos.</li></ul>\n<p><strong>﻿Requisitos:</strong></p><p><strong>﻿<br></strong></p>\n<ul><li>Graduação Superior em qualquer área (não necessariamente engenharia), demonstrando sólida formação acadêmica e capacidade analítica.</li><li>Experiência prévia em funções relacionadas a PMO (Project Management Office), planejamento ou controle de projetos.</li><li>Fortes habilidades com planilhas e ferramentas de análise de dados, com capacidade para interpretar e apresentar informações de forma clara e concisa.</li><li>Excelente organização e capacidade de gerenciar múltiplas tarefas simultaneamente, mantendo um alto nível de precisão e atenção aos detalhes.</li><li>Habilidades interpessoais sólidas, capazes de cultivar relacionamentos eficazes com uma variedade de stakeholders.</li><li>Preferencialmente sexo feminino, visando a diversidade e inclusão no ambiente de trabalho.</li><li>Desejável proficiência em inglês avançado</li><li>Data management: Pbi, Automação de relatorios e ppts..</li><li>Experiência com&nbsp;﻿<strong><em>Linguagem M ( PowerQuery ) </em></strong>﻿</li></ul>\n<p></p>\n<p></p>\n<p><br>\n\n</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:27:59 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://ptcgroup.global/"]}],"limit":1}'
@@ -116,9 +116,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Thu, 27 Jun 2024 13:37:16 GMT
+      - Tue, 30 Jul 2024 16:28:00 GMT
       Etag:
-      - W/"1719495436665"
+      - W/"1722356880099"
       Server:
       - openresty
       X-Cb-Engine:
@@ -134,7 +134,7 @@ http_interactions:
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '12'
+      - '15'
       Content-Length:
       - '538'
       Connection:
@@ -145,6 +145,6 @@ http_interactions:
         Group","identifier":{"permalink":"ptc-group-9de5","image_id":"szydmwyma8qxx3umkpqw","uuid":"b334425c-0d5a-4a43-8fde-11360ea69de5","entity_def_id":"organization","value":"PTC
         Group"},"linkedin":{"value":"https://www.linkedin.com/company/ptcgroup/"},"short_description":"PTC
         Group is an IT company that provides engineering, design, training, recruitment,
-        and consulting services.","rank_org":608456,"website_url":"https://ptcgroup.global/"}}]}'
-  recorded_at: Thu, 27 Jun 2024 13:37:16 GMT
+        and consulting services.","rank_org":443043,"website_url":"https://ptcgroup.global/"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:00 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_pinpointhq.yml b/spec/fixtures/cassettes/create_company_pinpointhq.yml
index 4da3905c..79887533 100644
--- a/spec/fixtures/cassettes/create_company_pinpointhq.yml
+++ b/spec/fixtures/cassettes/create_company_pinpointhq.yml
@@ -21,7 +21,7 @@ http_interactions:
       Server:
       - nginx
       Date:
-      - Thu, 27 Jun 2024 13:37:17 GMT
+      - Tue, 30 Jul 2024 16:28:00 GMT
       Content-Type:
       - text/html; charset=utf-8
       Transfer-Encoding:
@@ -39,28 +39,28 @@ http_interactions:
       Referrer-Policy:
       - strict-origin-when-cross-origin
       Etag:
-      - W/"8e83041ecb182c3079632825f6ace77a"
+      - W/"0b8a11d024f537dd24ca9f4d1ef77026"
       Cache-Control:
       - max-age=0, private, must-revalidate
       Content-Security-Policy-Report-Only:
       - 'default-src ''self'' https:; font-src ''self'' https: data:; img-src ''self''
         https: data:; object-src ''none''; media-src ''self'' https: blob:; script-src
-        ''self'' https: ''strict-dynamic'' ''nonce-ec97661ab4146d0f1bd6a369b5af19a0'';
+        ''self'' https: ''strict-dynamic'' ''nonce-b0ff7b091dbe2fd3786216f86048dbe6'';
         style-src ''self'' https: ''unsafe-inline''; connect-src ''self'' https: wss:;
         base-uri ''none''; report-uri /csp_violation_reports'
       Set-Cookie:
-      - LSW_WEB=LSW_WEB8; path=/
-      - _pinpoint_session=8i22AGupuCIMIVvAeqjsxxtDEngOSelyh6jaVsU2Yt5Wgz9N1bG%2FsjrYSOSHrHEfINgv0CsrpR5SnWfz3hlduWTCr0bE9tPczHpwq3FZOW7oVLL4SwaLGEX%2F%2FqtO%2BlYsWovjwGYvlapzAd%2Bp5j4bsfLkMSTxsDAsGRy2x0mz4OV9bHrWow8921MxNbYV43nnm%2BdhEFvTnSzsFCt7bSAypYQ7WHVBDs6QNeoKK89ZNABlnEUZI4hyNCR7cj1kZuxotG6YKWeOrv9CBrk%2FwjyzSQUUb5VJcqlM92WqJl1TN1UWVDxdimbHtdkyd%2FJR9%2Fv3ej4DNtz08b%2BVFPNllwpHXYGRiL4Q5ecDxWB7o62FMyvuMHMEKWoJF5RmGiU6hY1ZWW0CXRYjU6QcEnR0UWMF8wVnzQ%3D%3D--tTyDZwaeZ4crec%2Fi--6GBTgJ1Il%2Fna5BGp9SX%2F6w%3D%3D;
-        domain=.pinpointhq.com; path=/; expires=Thu, 04 Jul 2024 13:37:17 GMT; secure;
+      - LSW_WEB=LSW_WEB2; path=/
+      - _pinpoint_session=s1Gmi%2FnAZjLkze3K%2Bi%2FACCHLMeUhgVknl5BBiRmG%2F2yldyIcQE%2B%2FlgB77Fl7Ka6RuIv%2Fh6e74oniRm7pYNmCy383b%2F7tNvHXPAvrOTMp9kK0MsNByK5qT5q8oNrK1lFBX2%2Fzusd18cClY9EdCsiXepGPe4WQ5Rra6RlLaXkXUB8ZF0fdZ8BXuCbQsfY7VDwYpZalyoDwMRxMiSbAj%2BXkBLt8GqByU%2BcFhv833RUl7Rbn4col0uRPLBtyZz1HV%2FGcyUYIkzjR7KsHctF%2BzA14leOjFaSXeJ%2Bkb5m4HSue2ITrqR99KzhBaoAp8U9yd4cLnPYEJe4qZHjd2C3hijjzdzf5j%2B6PwEv72GbtuS7fCEGUt4dOd7WiJHpLPclZ1yAmtckdNRujPkANIU7uKRno6iSPmQ%3D%3D--sTDRp6%2FawRn78eFl--gKbnmM2GsmWia80ZKq5fJw%3D%3D;
+        domain=.pinpointhq.com; path=/; expires=Tue, 06 Aug 2024 16:28:00 GMT; secure;
         HttpOnly; SameSite=None
-      - ahoy_visit=a05732ab-e3c0-4bf9-8ac4-c7842569c79f; path=/; expires=Thu, 27 Jun
-        2024 17:37:17 GMT; secure
-      - ahoy_visitor=73582acf-5f3e-466e-87b7-8df4b5b2b041; path=/; expires=Sat, 27
-        Jun 2026 13:37:17 GMT; secure
+      - ahoy_visit=1b37235a-26b5-4e6e-aad9-22337927b7bb; path=/; expires=Tue, 30 Jul
+        2024 20:28:00 GMT; secure
+      - ahoy_visitor=455d62e8-7975-4649-b253-854cdad9c8e7; path=/; expires=Thu, 30
+        Jul 2026 16:28:00 GMT; secure
       X-Request-Id:
-      - 269949c4-b5de-4cf7-8616-378a9bf36692
+      - e22ff27b-ffb9-4374-ae63-e7ef897daab0
       X-Runtime:
-      - '0.259140'
+      - '0.231097'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Powered-By:
@@ -68,8 +68,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        <!DOCTYPE html>
<html lang="en-GB">
<head>
<script nonce="ec97661ab4146d0f1bd6a369b5af19a0">var _rollbarConfig = {"accessToken":"0ab41f8274e04d638238b61af91c297a","captureUncaught":true,"payload":{"environment":"production"},"ignoredMessages":["SP401 - Unauthorized"],"checkIgnore":function(isUncaught, args, payload) {
  var message = args[0];
  var ignoredMobileMessages = [
    `Uncaught SyntaxError: Unexpected token ';'`,
    `SyntaxError: Unexpected token ';'. Expected ')' to end a compound expression.`
  ];
  var userAgentContainsMobile = window && window.navigator && window.navigator.userAgent && window.navigator.userAgent.indexOf('Mobile') !== -1;
  if(userAgentContainsMobile && ignoredMobileMessages.includes(message)) {
    // ignore this message
    return true;
  }
  var ignoredMessages = [
    `ResizeObserver loop completed with undelivered notifications.`,
    `Script error.`
  ];
  if(ignoredMessages.includes(message)) {
    // ignore this message
    return true;
  }
}
};</script>
<script nonce="ec97661ab4146d0f1bd6a369b5af19a0">!function(r){var e={};function o(n){if(e[n])return e[n].exports;var t=e[n]={i:n,l:!1,exports:{}};return r[n].call(t.exports,t,t.exports,o),t.l=!0,t.exports}o.m=r,o.c=e,o.d=function(r,e,n){o.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},o.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},o.t=function(r,e){if(1&e&&(r=o(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var t in r)o.d(n,t,function(e){return r[e]}.bind(null,t));return n},o.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return o.d(e,"a",e),e},o.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},o.p="",o(o.s=0)}([function(r,e,o){"use strict";var n=o(1),t=o(5);_rollbarConfig=_rollbarConfig||{},_rollbarConfig.rollbarJsUrl=_rollbarConfig.rollbarJsUrl||"https://cdn.rollbar.com/rollbarjs/refs/tags/v2.26.1/rollbar.min.js",_rollbarConfig.async=void 0===_rollbarConfig.async||_rollbarConfig.async;var a=n.setupShim(window,_rollbarConfig),l=t(_rollbarConfig);window.rollbar=n.Rollbar,a.loadFull(window,document,!_rollbarConfig.async,_rollbarConfig,l)},function(r,e,o){"use strict";var n=o(2),t=o(3);function a(r){return function(){try{return r.apply(this,arguments)}catch(r){try{console.error("[Rollbar]: Internal error",r)}catch(r){}}}}var l=0;function i(r,e){this.options=r,this._rollbarOldOnError=null;var o=l++;this.shimId=function(){return o},"undefined"!=typeof window&&window._rollbarShims&&(window._rollbarShims[o]={handler:e,messages:[]})}var s=o(4),d=function(r,e){return new i(r,e)},c=function(r){return new s(d,r)};function u(r){return a((function(){var e=this,o=Array.prototype.slice.call(arguments,0),n={shim:e,method:r,args:o,ts:new Date};window._rollbarShims[this.shimId()].messages.push(n)}))}i.prototype.loadFull=function(r,e,o,n,t){var l=!1,i=e.createElement("script"),s=e.getElementsByTagName("script")[0],d=s.parentNode;i.crossOrigin="",i.src=n.rollbarJsUrl,o||(i.async=!0),i.onload=i.onreadystatechange=a((function(){if(!(l||this.readyState&&"loaded"!==this.readyState&&"complete"!==this.readyState)){i.onload=i.onreadystatechange=null;try{d.removeChild(i)}catch(r){}l=!0,function(){var e;if(void 0===r._rollbarDidLoad){e=new Error("rollbar.js did not load");for(var o,n,a,l,i=0;o=r._rollbarShims[i++];)for(o=o.messages||[];n=o.shift();)for(a=n.args||[],i=0;i<a.length;++i)if("function"==typeof(l=a[i])){l(e);break}}"function"==typeof t&&t(e)}()}})),d.insertBefore(i,s)},i.prototype.wrap=function(r,e,o){try{var n;if(n="function"==typeof e?e:function(){return e||{}},"function"!=typeof r)return r;if(r._isWrap)return r;if(!r._rollbar_wrapped&&(r._rollbar_wrapped=function(){o&&"function"==typeof o&&o.apply(this,arguments);try{return r.apply(this,arguments)}catch(o){var e=o;throw e&&("string"==typeof e&&(e=new String(e)),e._rollbarContext=n()||{},e._rollbarContext._wrappedSource=r.toString(),window._rollbarWrappedError=e),e}},r._rollbar_wrapped._isWrap=!0,r.hasOwnProperty))for(var t in r)r.hasOwnProperty(t)&&(r._rollbar_wrapped[t]=r[t]);return r._rollbar_wrapped}catch(e){return r}};for(var p="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,captureEvent,captureDomContentLoaded,captureLoad".split(","),f=0;f<p.length;++f)i.prototype[p[f]]=u(p[f]);r.exports={setupShim:function(r,e){if(r){var o=e.globalAlias||"Rollbar";if("object"==typeof r[o])return r[o];r._rollbarShims={},r._rollbarWrappedError=null;var l=new c(e);return a((function(){e.captureUncaught&&(l._rollbarOldOnError=r.onerror,n.captureUncaughtExceptions(r,l,!0),e.wrapGlobalEventHandlers&&t(r,l,!0)),e.captureUnhandledRejections&&n.captureUnhandledRejections(r,l,!0);var a=e.autoInstrument;return!1!==e.enabled&&(void 0===a||!0===a||function(r){return!("object"!=typeof r||void 0!==r.page&&!r.page)}(a))&&r.addEventListener&&(r.addEventListener("load",l.captureLoad.bind(l)),r.addEventListener("DOMContentLoaded",l.captureDomContentLoaded.bind(l))),r[o]=l,l}))()}},Rollbar:c}},function(r,e,o){"use strict";function n(r,e,o,n){r._rollbarWrappedError&&(n[4]||(n[4]=r._rollbarWrappedError),n[5]||(n[5]=r._rollbarWrappedError._rollbarContext),r._rollbarWrappedError=null);var t=e.handleUncaughtException.apply(e,n);o&&o.apply(r,n),"anonymous"===t&&(e.anonymousErrorsPending+=1)}r.exports={captureUncaughtExceptions:function(r,e,o){if(r){var t;if("function"==typeof e._rollbarOldOnError)t=e._rollbarOldOnError;else if(r.onerror){for(t=r.onerror;t._rollbarOldOnError;)t=t._rollbarOldOnError;e._rollbarOldOnError=t}e.handleAnonymousErrors();var a=function(){var o=Array.prototype.slice.call(arguments,0);n(r,e,t,o)};o&&(a._rollbarOldOnError=t),r.onerror=a}},captureUnhandledRejections:function(r,e,o){if(r){"function"==typeof r._rollbarURH&&r._rollbarURH.belongsToShim&&r.removeEventListener("unhandledrejection",r._rollbarURH);var n=function(r){var o,n,t;try{o=r.reason}catch(r){o=void 0}try{n=r.promise}catch(r){n="[unhandledrejection] error getting `promise` from event"}try{t=r.detail,!o&&t&&(o=t.reason,n=t.promise)}catch(r){}o||(o="[unhandledrejection] error getting `reason` from event"),e&&e.handleUnhandledRejection&&e.handleUnhandledRejection(o,n)};n.belongsToShim=o,r._rollbarURH=n,r.addEventListener("unhandledrejection",n)}}}},function(r,e,o){"use strict";function n(r,e,o){if(e.hasOwnProperty&&e.hasOwnProperty("addEventListener")){for(var n=e.addEventListener;n._rollbarOldAdd&&n.belongsToShim;)n=n._rollbarOldAdd;var t=function(e,o,t){n.call(this,e,r.wrap(o),t)};t._rollbarOldAdd=n,t.belongsToShim=o,e.addEventListener=t;for(var a=e.removeEventListener;a._rollbarOldRemove&&a.belongsToShim;)a=a._rollbarOldRemove;var l=function(r,e,o){a.call(this,r,e&&e._rollbar_wrapped||e,o)};l._rollbarOldRemove=a,l.belongsToShim=o,e.removeEventListener=l}}r.exports=function(r,e,o){if(r){var t,a,l="EventTarget,Window,Node,ApplicationCache,AudioTrackList,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");for(t=0;t<l.length;++t)r[a=l[t]]&&r[a].prototype&&n(e,r[a].prototype,o)}}},function(r,e,o){"use strict";function n(r,e){this.impl=r(e,this),this.options=e,function(r){for(var e=function(r){return function(){var e=Array.prototype.slice.call(arguments,0);if(this.impl[r])return this.impl[r].apply(this.impl,e)}},o="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,_createItem,wrap,loadFull,shimId,captureEvent,captureDomContentLoaded,captureLoad".split(","),n=0;n<o.length;n++)r[o[n]]=e(o[n])}(n.prototype)}n.prototype._swapAndProcessMessages=function(r,e){var o,n,t;for(this.impl=r(this.options);o=e.shift();)n=o.method,t=o.args,this[n]&&"function"==typeof this[n]&&("captureDomContentLoaded"===n||"captureLoad"===n?this[n].apply(this,[t[0],o.ts]):this[n].apply(this,t));return this},r.exports=n},function(r,e,o){"use strict";r.exports=function(r){return function(e){if(!e&&!window._rollbarInitialized){for(var o,n,t=(r=r||{}).globalAlias||"Rollbar",a=window.rollbar,l=function(r){return new a(r)},i=0;o=window._rollbarShims[i++];)n||(n=o.handler),o.handler._swapAndProcessMessages(l,o.messages);window[t]=n,window._rollbarInitialized=!0}}}}]);</script>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  
  <title>Jobs at Bath Spa University | Bath Spa University Careers</title>
  <meta name="description" content="Learn more about working at Bath Spa University and discover our latest career opportunities">

  <style>
    :root {
      --theme-primary-color: #455C51;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #ED9D85;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <script nonce="ec97661ab4146d0f1bd6a369b5af19a0">
//<![CDATA[

    window.essentialCookiesOnly = false;

    window.legacyCookieData = {"href":"/cookie-policy","message":"We use cookies to ensure you get the best experience on our website.","dismiss":"Got it!","link":"Learn more"};

    window.cookieConsentData = {"customContent":{"notice":"We use cookies to ensure you get the best experience on our website.","explanation":"We use cookies to ensure the basic functionalities of the website and to enhance your online experience. You can choose for each category to opt-in/out whenever you want. For more details relative to cookies and other sensitive data, please read the full <a href='/cookie-policy'>privacy policy</a>.","further_information":null},"translations":{"accept_all":"Accept all","close":"Close","cookie_preferences":"Cookie preferences","cookies":"Cookies","description":"Description","domain":"Domain","expiration":"Expiration","more_information":"More information","name":"Name","reject_all":"Reject all","save_settings":"Save settings","settings":"Settings","strictly_necessary_cookies":"Strictly necessary cookies","these_cookies_are_essential":"These cookies are essential for the proper functioning of our website. Without these cookies, the website may not work properly.","as_soon_as_browser_window_is_closed":"As soon as browser window is closed","allows_us_to_associate_file_uploads":"Allows us to associate file uploads to our file storage provider with your form submissions","allows_our_load_balancer":"Allows our load balancer to send your specific traffic to the same backend server","saves_your_decisions":"Saves your decisions about these cookies so we don't need to ask every time","analytics_and_performance_cookies":"Analytics and Performance cookies","these_cookies_remember_the_choices":"These cookies allow the website to remember the choices you have made in the past","internal_metrics_collector":"We use an internal metrics collector to understand interactions with our website over time","six_months":"Six months","two_years":"Two years","four_hours":"Four hours"}};

//]]>
</script>
  <script src="https://d2n5ied94mazop.cloudfront.net/packs/js/runtime-8c55631f3109106bc4ca.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/8860-0c486fe04c10f1fc1e69.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/application-d7ed07ec9f5dbdd3870f.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/7758-500534d14de13d6d913d.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/4934-7ef1df48c38cb8a32707.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cloudinary-4e5eb5d8dc0e193d4cef.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cookieconsent-76ba7ccf84597c35e667.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cdp-84feff2ddc8a9978561d.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/gtm-data-layer-9c7afd0f3a5aa7c9719c.js" data-turbolinks-track="reload" nonce="ec97661ab4146d0f1bd6a369b5af19a0" defer="defer"></script>
  <link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/application-55200c3b.css" data-turbolinks-track="reload" />
<link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/cookieconsent-4c4dfb09.css" data-turbolinks-track="reload" />

  <meta name="turbolinks-cache-control" content="no-preview">

  <meta name="csrf-param" content="authenticity_token" />
<meta name="csrf-token" content="2H3x2vZw4M2jHFl1byY/YD03C8XUuCMJG/ROFP+sfJHTszAU60qPZ/jZjzagdpyDdC2v22HKyiTVn6FEXdmiTw==" />
  <meta name="csp-nonce" content="ec97661ab4146d0f1bd6a369b5af19a0" />

  <link rel="shortcut icon" type="image/x-icon" href="https://res.cloudinary.com/pinpointhq/image/upload/c_fill,f_auto,h_32,q_auto,w_32/v1/uploads/production/lyby5aqq3zkcbluwtwgv.png" />

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <script src="https://kit.fontawesome.com/832bb86d52.js" crossorigin="anonymous" nonce="ec97661ab4146d0f1bd6a369b5af19a0"></script>

  

    <link rel="alternate" type="application/rss+xml" title="RSS" href="https://bathspa.pinpointhq.com/jobs.rss" />


  
    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;600;700&amp;display=swap" rel="stylesheet">
    <style>
      body,
      input {
        font-family: Montserrat, "GTWalsheimPro", "Helvetica Neue", "Helvetica", sans-serif !important;
      }
    </style>


  
    <style type="text/css">
      /* (Default Options) Custom Type to allow us to use both of our brand typefaces in heros etc */
.pinpoint-block--hero .careers-hero-block__title {
font-weight: 700;
}
.pinpoint-block--text .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
margin-bottom: 20px;
}
.pinpoint-block--text .careers-block__trix {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--cards .careers-card-block__h3 {
font-weight: 700;
line-height: 1.2;
}
.pinpoint-block--cards .careers-card-block__p {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--jobs .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
}

/* (Default Options) Custom Footer */
.external-footer {
padding: 32px;
}

/* (Default Options) Testimonial Block */
.pinpoint-block--testimonial img {
border-radius: 185px;
}
.pinpoint-block--testimonial cite {
font-weight: 700 !important;
letter-spacing: 3px;
}
.pinpoint-block--testimonial .careers-testimonial-block {
align-items: center;
}

/* (Default Options) External Panels - e.g. titles on JDs, Interview Scheduling, etc.) */
.external-panel .external-panel__title {
font-weight: 700;
}

/* (Default Options) Custom Hero Image Positioning */
.careers-hero-block--image {
background-position: center;
}

/* (Default Options) Hide the Logo Text */
.careers-navigation-block__logo-text,
.careers-hero-block__logo-text {
display: none;
}

/* (Default Options) Make hero bigger because people like to see video and pictures */
.careers-hero-block-container {
padding-top: 80px !important;
padding-bottom: 80px !important;
}

/* --------------------------- AS ----------------------------- */

/* Customize navbar */
.pinpoint-block--navigation {
  padding-top: 5px;
  padding-bottom: 5px;
  background-color: #ffffff;
}

/* Set logo width */
@media (min-width: 768px) {
  .pinpoint-block--navigation img,
  .careers-hero-block--align-center img {
    width: 60px !important;
    height: auto !important;
  }
}

/* Customize nav items */
.careers-navigation-block__menu-item {
  color: #6D6D6D !important;
  background-color: transparent !important;
  text-transform: uppercase;
}

.careers-navigation-block__sub-nav-menu {
  color: #6D6D6D !important;
  background-color: #ffffff !important;
}

.careers-navigation-block__menu-section--center > div > div > .careers-navigation-block__menu-item > div {
  box-shadow: 0px 0px 10px -4px rgb(0 0 0 / 45%);
  overflow: hidden;
}

.careers-navigation-block__menu-item:hover,
.careers-navigation-block__sub-nav-menu:hover {
  color: #007EAC !important;
}
    </style>


    




  

  <meta property="og:url" content="https://bathspa.pinpointhq.com/">
<meta property="og:type" content="website">
<meta property="og:locale" content="en_GB">
<meta property="og:title" content="Careers at Bath Spa University">
<meta property="og:description" content="Bath Spa University is where creative minds meet. Offering a wide range of courses across the arts, sciences, education, social science and business to over 7,500 students, the University employs outstanding creative professionals which support its aim to be a leading educational institution...">
<meta property="og:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@pinpointhq">
<meta name="twitter:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">

  <script nonce="ec97661ab4146d0f1bd6a369b5af19a0">
//<![CDATA[

    window.railsEnv = "production";

//]]>
</script>
  

    <link href="https://bathspa.pinpointhq.com/" rel="canonical" />
</head>

<body dir='auto' class="external-body pinpoint-page pinpoint-page--home theme-default">

  

  
  <style>
    :root {
      --theme-primary-color: #007eac;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #007eac;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <style>
    @media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {
      .theme-primary-color-ie-override {
        color: #007eac !important;
      }
      .theme-primary-background-color-ie-override {
        background-color: #007eac !important;
      }
      .theme-primary-border-color-ie-override {
        border-color: #007eac !important;
      }
      .theme-secondary-color-ie-override {
        color: #F4F4F4 !important;
      }
      .theme-secondary-background-color-ie-override {
        background-color: #F4F4F4 !important;
      }
      .theme-secondary-border-color-ie-override {
        border-color: #F4F4F4 !important;
      }
      .theme-highlight-color-ie-override {
        color: #007eac !important;
      }
      .theme-highlight-background-color-ie-override {
        background-color: #007eac !important;
      }
      .theme-highlight-border-color-ie-override {
        border-color: #007eac !important;
      }
    }
  </style>


  <div class="external-content" id="external-content-body">


    






<main class="external-main">

  
    <section class="pinpoint-block pinpoint-block--navigation careers-block careers-navigation-block careers-navigation-block--justified theme-primary-background-color-ie-override" style="">

  <div class=" frow frow--gutters frow--justify-between frow--items-center frow--nowrap">

  <div class="careers-navigation-block__menu-section--left">
    <a style="display: block" href="/">

      <div class="frow frow--items-center frow--gutters">

        <span class="careers-navigation-block__logo-text" style="color: inherit">
          Careers at
        </span>

        <div class="hide-at-sm-block"><img alt="Bath Spa University - Home" style="width: 21.6px; height: 30.0px;" width="21" height="30" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lQTkRRd0xqQjROakF1TUFZNkJrVlUiLCJleHAiOm51bGwsInB1ciI6InZhcmlhdGlvbiJ9fQ==--a8aaf45d691ceff55bb4ecfcc9bec21f806890fa/BSU%20master%20logo.png" /></div><div class="hide-sm-block"><img alt="Bath Spa University - Home" style="width: 36.1px; height: 50.0px;" width="36" height="50" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lRTkRRd0xqQjRNVEF3TGpBR09nWkZWQT09IiwiZXhwIjpudWxsLCJwdXIiOiJ2YXJpYXRpb24ifX0=--5fd990b5737f041b8b006e0f6f8b9bd3043c9631/BSU%20master%20logo.png" /></div>

      </div>

</a>  </div>

  <div class="careers-navigation-block__menu-section--center">

    <script type="application/json" id="js-react-on-rails-context">{"railsEnv":"production","inMailer":false,"i18nLocale":"en","i18nDefaultLocale":"en","rorVersion":"13.0.2","rorPro":false,"href":"https://bathspa.pinpointhq.com/","location":"/","scheme":"https","host":"bathspa.pinpointhq.com","port":null,"pathname":"/","search":null,"httpAcceptLanguage":null,"serverSide":false}</script>
<div class="careers-navigation-overflow-menu" style="" id="External::Careerspage::Responsivenavigation-react-component-fd3c93d2-6942-4c93-843b-64dca7527ee1"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Responsivenavigation" data-dom-id="External::Careerspage::Responsivenavigation-react-component-fd3c93d2-6942-4c93-843b-64dca7527ee1">{"menuItems":[],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

  <div class="careers-navigation-block__menu-section--right">

      <a class="careers-navigation-block__menu-item" style="" href="/?scroll_to=js-careers-jobs-block">View Jobs</a>

  </div>

</div>


</section>


    <section class="pinpoint-block pinpoint-block--hero careers-hero-block careers-hero-block--align-left careers-hero-block--image" style="background-color: #222222; color: #ffffff; background-image: linear-gradient(rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0.5)), url(https://res.cloudinary.com/pinpointhq/image/upload/f_auto,q_auto/v1/uploads/production/h9mzkgn15hekkvcjcydg);">



      <div class="external-content-wrap careers-hero-block__content-wrap">

        <div class="careers-hero-block__content">

          <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-hero-block__title">Work at Bath Spa University</h2>
            <p class="careers-hero-block__text">Our purpose is to challenge our staff and students to realise their talent and thrive.</p>

          </div>

            <div>
              <a aria-label="" class="external-button external-button--theme-primary mar-b-5 mar-sm-b-10 theme-primary-background-color-ie-override theme-primary-border-color-ie-override" href="#js-careers-jobs-block">View Jobs</a>
            </div>

        </div>

      </div>


</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Our values</h2>

            <div class="careers-block__trix external-panel text-center"><div>At Bath Spa we recognise that equality, diversity and inclusion are essential to building the creative, innovative and nurturing ethos that we pride ourselves on. That’s why <strong>Inclusion</strong> forms one of our four core cultural values alongside <strong>Respect</strong>, <strong>Collaboration </strong>and <strong>Sustainability</strong>.</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--video careers-block">

  <div class="external-content-wrap">

    <div id="External::Careerspage::Video-react-component-34a9d4d1-cd57-4d1b-aa52-db6e647a09ff"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Video" data-dom-id="External::Careerspage::Video-react-component-34a9d4d1-cd57-4d1b-aa52-db6e647a09ff">{"provider":"youtube","videoId":"https://www.youtube.com/embed/oMniClzyzpI?si=64E94e2XuaBamGkj","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-1 careers-card-block careers-card-block--align-left careers-card-block--variant-large">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-sm-7-12 col-sm-order-1 col-order-2">

        <div class="careers-card-block__content">

          
          <h3 class="careers-card-block__h3">Why apply to Bath Spa University?</h3>
          <div class="careers-card-block__p "><div>We are the UK's university of choice for creativity, culture, enterprise and education, and are home to students and staff from over 80 countries. The University is committed to recruiting and retaining the highest quality staff.<br><br>We provide an environment that respects and celebrates all members of our community, and is free from discrimination, prejudice, harassment and bullying. So much so, we are proud to have a wide range of staff networks set-up to foster diversity and inclusion here at Bath Spa. <br><br>These include:</div><ul>
<li>BathSpa+ (for our LGBTQIA+ Staff) </li>
<li>Disabled Staff Network</li>
<li>Women's Staff Network </li>
<li>Neurodiversity Staff Network </li>
<li>Parent and Carers Network </li>
<li>Global Inclusivity Network for staff who identify as Black, Asian, mixed race, or another minoritised ethnicity. </li>
</ul><div>We also have a Staff Equalities Network for colleagues interested in activism and enacting change at a grassroots level.<br><br>These are some of the fab reasons why 82% of our staff said they would recommend us to a friend as a good employer in the last staff survey.<br><br>Carry on scrolling for more great reasons...</div></div>
          

        </div>

      </div>


        <div class="col-sm-5-12 col-sm-order-2 col-order-1">

            <img class="careers-card-block__image cld-responsive" alt="" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,q_auto,w_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /><noscript><img class="careers-card-block__image" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /></noscript>


        </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--image-gallery careers-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div id="External::Careerspage::Imagegallery-react-component-3191762d-002f-4963-8361-863b31f701a9"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Imagegallery" data-dom-id="External::Careerspage::Imagegallery-react-component-3191762d-002f-4963-8361-863b31f701a9">{"cloudinaryImages":[{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/lpwat6i2mpwpgzkomc68","width":5332,"height":3552,"alt":"","publicId":"uploads/production/lpwat6i2mpwpgzkomc68"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/gxj4mi4kl0oxer7wdwgi","width":1000,"height":1000,"alt":"","publicId":"uploads/production/gxj4mi4kl0oxer7wdwgi"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/otke5vlkmrg6a5gp0hxl","width":1000,"height":1500,"alt":"","publicId":"uploads/production/otke5vlkmrg6a5gp0hxl"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/iqzgcwcu2zr0358ckf37","width":7952,"height":5304,"alt":"","publicId":"uploads/production/iqzgcwcu2zr0358ckf37"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/toiyerugdnkgji0dsfyh","width":5125,"height":3417,"alt":"","publicId":"uploads/production/toiyerugdnkgji0dsfyh"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/zrw1nruistevzollfwuu","width":5760,"height":3840,"alt":"","publicId":"uploads/production/zrw1nruistevzollfwuu"}],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Benefits</h2>

            <div class="careers-block__trix external-panel text-center">We work hard, but we also know you have a family, friends, hobbies, and a life outside the office. That’s why we offer a great benefits package, not just a competitive salary.</div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /></noscript>
          <h3 class="careers-card-block__h3">41 days holiday</h3>
          <div class="careers-card-block__p "><div>This includes bank holidays and University closure days. Everyone needs a healthy, happy, and productive life. This means you'll need time to rest and recover.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /></noscript>
          <h3 class="careers-card-block__h3">Generous pension plans</h3>
          <div class="careers-card-block__p "><div>We've got you covered for the future. Work in the comfort of knowing that all your hard work is not only paying off now but also setting you up for the future.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /></noscript>
          <h3 class="careers-card-block__h3">Flexible working</h3>
          <div class="careers-card-block__p "><div>We know life is busy so, where we can, we support flexible working to ensure our teams are happy, productive and listened to.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /></noscript>
          <h3 class="careers-card-block__h3">Onsite nursery </h3>
          <div class="careers-card-block__p "><div>Reduce the morning stress by dropping the kids off at the onsite nursery. We've got you and your family covered.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /></noscript>
          <h3 class="careers-card-block__h3">Employee assistance programme </h3>
          <div class="careers-card-block__p "><div>We've teamed up with Telus Health to provide you with extra support when needed. Whether it is health, family, money, work or yourself, Telus Health is only a phone call away.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /></noscript>
          <h3 class="careers-card-block__h3">A team that cares</h3>
          <div class="careers-card-block__p "><div>You’ll be joining a team of smart, capable, helpful people that want you to win, our students to win and our University and community to grow. Not to mention our team of care dogs who are on hand to put a smile on your face if needed.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--column-start ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-left">We asked our teams...</h2>

            <div class="careers-block__trix external-panel text-left"><div>"Beyond pay and benefits, what things make Bath Spa a great place to work?"</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--carousel careers-block careers-carousel-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


      <div id="External::Careerspage::Carousel-react-component-0798e1f2-2cdd-47f0-9da4-047f39f8a9a4"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Carousel" data-dom-id="External::Careerspage::Carousel-react-component-0798e1f2-2cdd-47f0-9da4-047f39f8a9a4">{"renderedBlocks":["\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The sense of community, my colleagues, the students, the campus, the general atmosphere of positivity and appreciation.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Sarah \n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;A culture that support equal access for staff and students.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Meg\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;Beautiful campus with the opportunity to learn new things from those around us. Also,\na good team working atmosphere where team members are willing to help and support each other. Cultivating a fun, happy and hard-working culture where everyone feels valued.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Simon\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The people are wonderful - their values are ones I agree with and try to live by.\n\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Suman\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e"],"autoplay":true,"autoplaySpeedMs":10000,"showDots":true,"infinite":true,"scrollAmount":1,"showAmount":1,"scrollSpeedMs":500,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

</div>
</section>


    <section class="pinpoint-block pinpoint-block--jobs careers-block" id="js-careers-jobs-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <h2 class="careers-block__h2 text-center">Current Opportunities</h2>

      <div class="careers-block__content pad-b-3">

        <div class="frow frow--gutters frow--gutters-md-2x frow--items-end">

          <div class="col-flex-grow-1">

            <form role="search">
              <button type="submit" disabled style="display: none" aria-hidden="true"></button>
              <div id="Shared::Search-react-component-1c393d23-3579-4382-97d3-5789a6fdc3d3"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="Shared::Search" data-dom-id="Shared::Search-react-component-1c393d23-3579-4382-97d3-5789a6fdc3d3">{"target":"external:jobs:index:5494","willUpdateUrl":true,"searchPlaceholderText":"Search...","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      

            </form>

          </div>


            <div class="col-md-6-12">
              <div id="External::Filters-react-component-f8509e57-2cfa-4af1-8726-c9e430726983"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Filters" data-dom-id="External::Filters-react-component-f8509e57-2cfa-4af1-8726-c9e430726983">{"filters":[{"name":"location","attribute":"location_id","values":[],"items":[{"label":"Bath","value":10393},{"label":"Bath - Corsham Court","value":14961},{"label":"Bath - Locksbrook Campus","value":14959},{"label":"Bath - Newton Park","value":14958},{"label":"Bath - Newton Park \u0026 Locksbrook","value":14962},{"label":"Bath - Palace Yard Mews","value":17471},{"label":"Bath - Sion Hill Campus","value":14960},{"label":"Bath Spa University London","value":23470},{"label":"London - New City College ","value":14963},{"label":"Remote","value":27327},{"label":"The Studio - Palace Yard Mews","value":26635},{"label":"Various - Across SW England ","value":28564}],"translations":{"singleItem":"Location","pluralItems":"Locations","allItems":"All Locations"}},{"name":"department","attribute":"department_id","values":[],"items":[{"label":" Innovation and Knowledge Exchange Centre","value":37689},{"label":"Academic Planning","value":19086},{"label":"Bath Business school - London ","value":34431},{"label":"Bath School of Music and Performing Arts ","value":31904},{"label":"Bath Spa University London ","value":29962},{"label":"Business School","value":19085},{"label":"Careers and Employability","value":28533},{"label":"Catering ","value":34135},{"label":"Centre for Educational Partnerships ","value":38139},{"label":"Chancelry","value":25472},{"label":"Data \u0026 Insights Service","value":33104},{"label":"EAU","value":32064},{"label":"EAU Short Courses","value":29808},{"label":"Estates","value":25473},{"label":"Estates and Services","value":30675},{"label":"Estates/Security","value":30951},{"label":"External Affairs Unit","value":25474},{"label":"Facilities and Services","value":30050},{"label":"Finance","value":25475},{"label":"Future Students","value":31406},{"label":"Governance \u0026 Engagement ","value":35154},{"label":"Governance Legal \u0026 Compliance","value":25476},{"label":"HR","value":19087},{"label":"IT Services","value":25477},{"label":"Learning Innovation \u0026 Skills Unit /  Schools Technical Services","value":34216},{"label":"Learning, Innovation and Skills","value":36124},{"label":"Learning, Innovation and Skills: Academic Skills","value":28307},{"label":"Library and Learning Services","value":28326},{"label":"Marketing and Applicant Comms, Future Students ","value":29815},{"label":"Portfolio and Planning","value":30409},{"label":"Research \u0026 Enterprise","value":25478},{"label":"Research \u0026 Graduate Affairs","value":33220},{"label":"School Of Science","value":29645},{"label":"School of Art, Film \u0026 Media","value":36272},{"label":"School of Design","value":19088},{"label":"School of Education","value":25479},{"label":"School of Film \u0026 Arts","value":19084},{"label":"School of Music \u0026 Performing Arts","value":19083},{"label":"School of Science","value":29646},{"label":"School of Sciences","value":25480},{"label":"School of Writing Publishing \u0026 Humanities","value":25481},{"label":"School of Writing, Publishing and the Humanities","value":29246},{"label":"Strategic Projects \u0026 Delivery Unit","value":25482},{"label":"Strategic Projects and Change Unit","value":36037},{"label":"Student Accommodation ","value":35035},{"label":"Student Experience","value":25483},{"label":"Student Housing ","value":33411},{"label":"Student Wellbeing SErvices","value":31929},{"label":"Student Wellbeing Services ","value":28279},{"label":"Student and Registry Services","value":29262},{"label":"Student wellbeing Services","value":31930},{"label":"Technical Services","value":30746},{"label":"Wellbeing \u0026 Disability","value":30147},{"label":"Writing, Publishing \u0026 Humanities ","value":29781}],"translations":{"singleItem":"Department","pluralItems":"Departments","allItems":"All Departments"}}],"isUrlFilterable":true,"target":"external:jobs:index:5494","willUpdateUrl":true,"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


            </div>


        </div>

      </div>

    </div>

  </div>


  <div id="External::Jobs-react-component-8315e21a-072f-4f03-a0ea-a0ca8cb40226"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Jobs" data-dom-id="External::Jobs-react-component-8315e21a-072f-4f03-a0ea-a0ca8cb40226">{"additionalColumns":[],"url":"/postings.json","target":"external:jobs:index:5494","translations":{"job_title":"Job Title","department":"Department","division":"Division","requisition_id":"Requisition ID","structure_custom_group_one":"Custom","location":"Location","employment_type":"Employment Type","no_positions":"There are currently no positions advertised.","no_opportunities":"There are currently no opportunities based on your filters. Please try again, or register your interest.","workplace_type":"Workplace type"},"structures":[{"key":"location","keyPlural":"locations","name":"Location","namePlural":"Locations","nameAccessor":"locationName","columnVisibilityAccessor":"locationsColumnVisible"},{"key":"department","keyPlural":"departments","name":"Department","namePlural":"Departments","nameAccessor":"departmentName","columnVisibilityAccessor":"departmentsColumnVisible"}],"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"showPagination":false,"pageSize":null,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      



</section>



</main>


  </div>

    <footer class="external-footer theme-secondary-background-color-ie-override" id="external-content-footer">

  <div class="external-content-wrap">


    <div class="external-footer__content">

      <div class="frow frow--justify-between frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-3x">

        <div>

          <div class="frow frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-2x">


              <a class="external-footer__link" target="_blank" href="https://www.bathspa.ac.uk/">

                Bath Spa University <i class="fas fa-external-link-alt mar-l-1"></i>

</a>

            <a class="external-footer__link" target="_blank" href="/themes/2198/privacy_policy">
              Privacy Policy
</a>
              <a class='external-footer__link' data-cc="c-settings" aria-label="View cookie settings" tabindex="0" role="button">
                Cookies
              </a>

            <div class="frow frow--gutters frow--items-center">
              <a class="external-footer__link" href="https://www.facebook.com/bath.spa.university" target="_blank" title="Bath Spa University&#39;s Facebook page." style="margin-right: 5px;"><i class="fab fa-facebook fa-lg" style="color: #3B5998"></i></a>
              
              
              
              <a class="external-footer__link" href="https://www.instagram.com/bathspauni" target="_blank" title="Bath Spa University&#39;s Instagram page." style="margin-right: 5px;"><img alt="Bath Spa University instagram" src="https://d2n5ied94mazop.cloudfront.net/packs/static/logos/external/instagram_logo-5139d56ff0927cddd11f.svg" /></a>
              
            </div>

          </div>

        </div>

        <div>

          <a class="external-footer__link" target="_blank" href="https://www.pinpointhq.com">Powered by Pinpoint</a>

        </div>

      </div>

    </div>

  </div>

  </div>

</footer>


  







    


</body>

-  recorded_at: Thu, 27 Jun 2024 13:37:17 GMT
+        <!DOCTYPE html>
<html lang="en-GB">
<head>
<script nonce="b0ff7b091dbe2fd3786216f86048dbe6">var _rollbarConfig = {"accessToken":"0ab41f8274e04d638238b61af91c297a","captureUncaught":true,"payload":{"environment":"production"},"ignoredMessages":["SP401 - Unauthorized"],"checkIgnore":function(isUncaught, args, payload) {
  var message = args[0];
  var ignoredMobileMessages = [
    `Uncaught SyntaxError: Unexpected token ';'`,
    `SyntaxError: Unexpected token ';'. Expected ')' to end a compound expression.`
  ];
  var userAgentContainsMobile = window && window.navigator && window.navigator.userAgent && window.navigator.userAgent.indexOf('Mobile') !== -1;
  if(userAgentContainsMobile && ignoredMobileMessages.includes(message)) {
    // ignore this message
    return true;
  }
  var ignoredMessages = [
    `ResizeObserver loop completed with undelivered notifications.`,
    `Script error.`
  ];
  if(ignoredMessages.includes(message)) {
    // ignore this message
    return true;
  }
}
};</script>
<script nonce="b0ff7b091dbe2fd3786216f86048dbe6">!function(r){var e={};function o(n){if(e[n])return e[n].exports;var t=e[n]={i:n,l:!1,exports:{}};return r[n].call(t.exports,t,t.exports,o),t.l=!0,t.exports}o.m=r,o.c=e,o.d=function(r,e,n){o.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},o.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},o.t=function(r,e){if(1&e&&(r=o(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var t in r)o.d(n,t,function(e){return r[e]}.bind(null,t));return n},o.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return o.d(e,"a",e),e},o.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},o.p="",o(o.s=0)}([function(r,e,o){"use strict";var n=o(1),t=o(5);_rollbarConfig=_rollbarConfig||{},_rollbarConfig.rollbarJsUrl=_rollbarConfig.rollbarJsUrl||"https://cdn.rollbar.com/rollbarjs/refs/tags/v2.26.1/rollbar.min.js",_rollbarConfig.async=void 0===_rollbarConfig.async||_rollbarConfig.async;var a=n.setupShim(window,_rollbarConfig),l=t(_rollbarConfig);window.rollbar=n.Rollbar,a.loadFull(window,document,!_rollbarConfig.async,_rollbarConfig,l)},function(r,e,o){"use strict";var n=o(2),t=o(3);function a(r){return function(){try{return r.apply(this,arguments)}catch(r){try{console.error("[Rollbar]: Internal error",r)}catch(r){}}}}var l=0;function i(r,e){this.options=r,this._rollbarOldOnError=null;var o=l++;this.shimId=function(){return o},"undefined"!=typeof window&&window._rollbarShims&&(window._rollbarShims[o]={handler:e,messages:[]})}var s=o(4),d=function(r,e){return new i(r,e)},c=function(r){return new s(d,r)};function u(r){return a((function(){var e=this,o=Array.prototype.slice.call(arguments,0),n={shim:e,method:r,args:o,ts:new Date};window._rollbarShims[this.shimId()].messages.push(n)}))}i.prototype.loadFull=function(r,e,o,n,t){var l=!1,i=e.createElement("script"),s=e.getElementsByTagName("script")[0],d=s.parentNode;i.crossOrigin="",i.src=n.rollbarJsUrl,o||(i.async=!0),i.onload=i.onreadystatechange=a((function(){if(!(l||this.readyState&&"loaded"!==this.readyState&&"complete"!==this.readyState)){i.onload=i.onreadystatechange=null;try{d.removeChild(i)}catch(r){}l=!0,function(){var e;if(void 0===r._rollbarDidLoad){e=new Error("rollbar.js did not load");for(var o,n,a,l,i=0;o=r._rollbarShims[i++];)for(o=o.messages||[];n=o.shift();)for(a=n.args||[],i=0;i<a.length;++i)if("function"==typeof(l=a[i])){l(e);break}}"function"==typeof t&&t(e)}()}})),d.insertBefore(i,s)},i.prototype.wrap=function(r,e,o){try{var n;if(n="function"==typeof e?e:function(){return e||{}},"function"!=typeof r)return r;if(r._isWrap)return r;if(!r._rollbar_wrapped&&(r._rollbar_wrapped=function(){o&&"function"==typeof o&&o.apply(this,arguments);try{return r.apply(this,arguments)}catch(o){var e=o;throw e&&("string"==typeof e&&(e=new String(e)),e._rollbarContext=n()||{},e._rollbarContext._wrappedSource=r.toString(),window._rollbarWrappedError=e),e}},r._rollbar_wrapped._isWrap=!0,r.hasOwnProperty))for(var t in r)r.hasOwnProperty(t)&&(r._rollbar_wrapped[t]=r[t]);return r._rollbar_wrapped}catch(e){return r}};for(var p="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,captureEvent,captureDomContentLoaded,captureLoad".split(","),f=0;f<p.length;++f)i.prototype[p[f]]=u(p[f]);r.exports={setupShim:function(r,e){if(r){var o=e.globalAlias||"Rollbar";if("object"==typeof r[o])return r[o];r._rollbarShims={},r._rollbarWrappedError=null;var l=new c(e);return a((function(){e.captureUncaught&&(l._rollbarOldOnError=r.onerror,n.captureUncaughtExceptions(r,l,!0),e.wrapGlobalEventHandlers&&t(r,l,!0)),e.captureUnhandledRejections&&n.captureUnhandledRejections(r,l,!0);var a=e.autoInstrument;return!1!==e.enabled&&(void 0===a||!0===a||function(r){return!("object"!=typeof r||void 0!==r.page&&!r.page)}(a))&&r.addEventListener&&(r.addEventListener("load",l.captureLoad.bind(l)),r.addEventListener("DOMContentLoaded",l.captureDomContentLoaded.bind(l))),r[o]=l,l}))()}},Rollbar:c}},function(r,e,o){"use strict";function n(r,e,o,n){r._rollbarWrappedError&&(n[4]||(n[4]=r._rollbarWrappedError),n[5]||(n[5]=r._rollbarWrappedError._rollbarContext),r._rollbarWrappedError=null);var t=e.handleUncaughtException.apply(e,n);o&&o.apply(r,n),"anonymous"===t&&(e.anonymousErrorsPending+=1)}r.exports={captureUncaughtExceptions:function(r,e,o){if(r){var t;if("function"==typeof e._rollbarOldOnError)t=e._rollbarOldOnError;else if(r.onerror){for(t=r.onerror;t._rollbarOldOnError;)t=t._rollbarOldOnError;e._rollbarOldOnError=t}e.handleAnonymousErrors();var a=function(){var o=Array.prototype.slice.call(arguments,0);n(r,e,t,o)};o&&(a._rollbarOldOnError=t),r.onerror=a}},captureUnhandledRejections:function(r,e,o){if(r){"function"==typeof r._rollbarURH&&r._rollbarURH.belongsToShim&&r.removeEventListener("unhandledrejection",r._rollbarURH);var n=function(r){var o,n,t;try{o=r.reason}catch(r){o=void 0}try{n=r.promise}catch(r){n="[unhandledrejection] error getting `promise` from event"}try{t=r.detail,!o&&t&&(o=t.reason,n=t.promise)}catch(r){}o||(o="[unhandledrejection] error getting `reason` from event"),e&&e.handleUnhandledRejection&&e.handleUnhandledRejection(o,n)};n.belongsToShim=o,r._rollbarURH=n,r.addEventListener("unhandledrejection",n)}}}},function(r,e,o){"use strict";function n(r,e,o){if(e.hasOwnProperty&&e.hasOwnProperty("addEventListener")){for(var n=e.addEventListener;n._rollbarOldAdd&&n.belongsToShim;)n=n._rollbarOldAdd;var t=function(e,o,t){n.call(this,e,r.wrap(o),t)};t._rollbarOldAdd=n,t.belongsToShim=o,e.addEventListener=t;for(var a=e.removeEventListener;a._rollbarOldRemove&&a.belongsToShim;)a=a._rollbarOldRemove;var l=function(r,e,o){a.call(this,r,e&&e._rollbar_wrapped||e,o)};l._rollbarOldRemove=a,l.belongsToShim=o,e.removeEventListener=l}}r.exports=function(r,e,o){if(r){var t,a,l="EventTarget,Window,Node,ApplicationCache,AudioTrackList,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");for(t=0;t<l.length;++t)r[a=l[t]]&&r[a].prototype&&n(e,r[a].prototype,o)}}},function(r,e,o){"use strict";function n(r,e){this.impl=r(e,this),this.options=e,function(r){for(var e=function(r){return function(){var e=Array.prototype.slice.call(arguments,0);if(this.impl[r])return this.impl[r].apply(this.impl,e)}},o="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,_createItem,wrap,loadFull,shimId,captureEvent,captureDomContentLoaded,captureLoad".split(","),n=0;n<o.length;n++)r[o[n]]=e(o[n])}(n.prototype)}n.prototype._swapAndProcessMessages=function(r,e){var o,n,t;for(this.impl=r(this.options);o=e.shift();)n=o.method,t=o.args,this[n]&&"function"==typeof this[n]&&("captureDomContentLoaded"===n||"captureLoad"===n?this[n].apply(this,[t[0],o.ts]):this[n].apply(this,t));return this},r.exports=n},function(r,e,o){"use strict";r.exports=function(r){return function(e){if(!e&&!window._rollbarInitialized){for(var o,n,t=(r=r||{}).globalAlias||"Rollbar",a=window.rollbar,l=function(r){return new a(r)},i=0;o=window._rollbarShims[i++];)n||(n=o.handler),o.handler._swapAndProcessMessages(l,o.messages);window[t]=n,window._rollbarInitialized=!0}}}}]);</script>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  
  <title>Jobs at Bath Spa University | Bath Spa University Careers</title>
  <meta name="description" content="Learn more about working at Bath Spa University and discover our latest career opportunities">

  <style>
    :root {
      --theme-primary-color: #455C51;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #ED9D85;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <script nonce="b0ff7b091dbe2fd3786216f86048dbe6">
//<![CDATA[

    window.essentialCookiesOnly = false;

    window.legacyCookieData = {"href":"/cookie-policy","message":"We use cookies to ensure you get the best experience on our website.","dismiss":"Got it!","link":"Learn more"};

    window.cookieConsentData = {"customContent":{"notice":"We use cookies to ensure you get the best experience on our website.","explanation":"We use cookies to ensure the basic functionalities of the website and to enhance your online experience. You can choose for each category to opt-in/out whenever you want. For more details relative to cookies and other sensitive data, please read the full <a href='/cookie-policy'>privacy policy</a>.","further_information":null},"translations":{"accept_all":"Accept all","close":"Close","cookie_preferences":"Cookie preferences","cookies":"Cookies","description":"Description","domain":"Domain","expiration":"Expiration","more_information":"More information","name":"Name","reject_all":"Reject all","save_settings":"Save settings","settings":"Settings","strictly_necessary_cookies":"Strictly necessary cookies","these_cookies_are_essential":"These cookies are essential for the proper functioning of our website. Without these cookies, the website may not work properly.","as_soon_as_browser_window_is_closed":"As soon as browser window is closed","allows_us_to_associate_file_uploads":"Allows us to associate file uploads to our file storage provider with your form submissions","allows_our_load_balancer":"Allows our load balancer to send your specific traffic to the same backend server","saves_your_decisions":"Saves your decisions about these cookies so we don't need to ask every time","analytics_and_performance_cookies":"Analytics and Performance cookies","these_cookies_remember_the_choices":"These cookies allow the website to remember the choices you have made in the past","internal_metrics_collector":"We use an internal metrics collector to understand interactions with our website over time","six_months":"Six months","two_years":"Two years","four_hours":"Four hours"}};

//]]>
</script>
  <script src="https://d2n5ied94mazop.cloudfront.net/packs/js/runtime-4ee0bc422406a939a04f.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/8860-54ebbc9015ed0678f9b4.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/application-7fc02963bbe1c1231110.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/7758-500534d14de13d6d913d.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/4934-7ef1df48c38cb8a32707.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cloudinary-4e5eb5d8dc0e193d4cef.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cookieconsent-76ba7ccf84597c35e667.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cdp-84feff2ddc8a9978561d.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/gtm-data-layer-9c7afd0f3a5aa7c9719c.js" data-turbolinks-track="reload" nonce="b0ff7b091dbe2fd3786216f86048dbe6" defer="defer"></script>
  <link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/application-79f60752.css" data-turbolinks-track="reload" />
<link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/cookieconsent-4c4dfb09.css" data-turbolinks-track="reload" />

  <meta name="turbolinks-cache-control" content="no-preview">

  <meta name="csrf-param" content="authenticity_token" />
<meta name="csrf-token" content="oN3MStenrCAeS2lLRfwDp9MmufH78ONg/EiOcUPNSiWUHExj6W5nseQTSSI6KH853FGmtgAJ9JMKIzoDhMS9Zw==" />
  <meta name="csp-nonce" content="b0ff7b091dbe2fd3786216f86048dbe6" />

  <link rel="shortcut icon" type="image/x-icon" href="https://res.cloudinary.com/pinpointhq/image/upload/c_fill,f_auto,h_32,q_auto,w_32/v1/uploads/production/lyby5aqq3zkcbluwtwgv.png" />

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <script src="https://kit.fontawesome.com/832bb86d52.js" crossorigin="anonymous" nonce="b0ff7b091dbe2fd3786216f86048dbe6"></script>

  

    <link rel="alternate" type="application/rss+xml" title="RSS" href="https://bathspa.pinpointhq.com/jobs.rss" />


  
    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;600;700&amp;display=swap" rel="stylesheet">
    <style>
      body,
      input {
        font-family: Montserrat, "GTWalsheimPro", "Helvetica Neue", "Helvetica", sans-serif !important;
      }
    </style>


  
    <style type="text/css">
      /* (Default Options) Custom Type to allow us to use both of our brand typefaces in heros etc */
.pinpoint-block--hero .careers-hero-block__title {
font-weight: 700;
}
.pinpoint-block--text .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
margin-bottom: 20px;
}
.pinpoint-block--text .careers-block__trix {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--cards .careers-card-block__h3 {
font-weight: 700;
line-height: 1.2;
}
.pinpoint-block--cards .careers-card-block__p {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--jobs .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
}

/* (Default Options) Custom Footer */
.external-footer {
padding: 32px;
}

/* (Default Options) Testimonial Block */
.pinpoint-block--testimonial img {
border-radius: 185px;
}
.pinpoint-block--testimonial cite {
font-weight: 700 !important;
letter-spacing: 3px;
}
.pinpoint-block--testimonial .careers-testimonial-block {
align-items: center;
}

/* (Default Options) External Panels - e.g. titles on JDs, Interview Scheduling, etc.) */
.external-panel .external-panel__title {
font-weight: 700;
}

/* (Default Options) Custom Hero Image Positioning */
.careers-hero-block--image {
background-position: center;
}

/* (Default Options) Hide the Logo Text */
.careers-navigation-block__logo-text,
.careers-hero-block__logo-text {
display: none;
}

/* (Default Options) Make hero bigger because people like to see video and pictures */
.careers-hero-block-container {
padding-top: 80px !important;
padding-bottom: 80px !important;
}

/* --------------------------- AS ----------------------------- */

/* Customize navbar */
.pinpoint-block--navigation {
  padding-top: 5px;
  padding-bottom: 5px;
  background-color: #ffffff;
}

/* Set logo width */
@media (min-width: 768px) {
  .pinpoint-block--navigation img,
  .careers-hero-block--align-center img {
    width: 60px !important;
    height: auto !important;
  }
}

/* Customize nav items */
.careers-navigation-block__menu-item {
  color: #6D6D6D !important;
  background-color: transparent !important;
  text-transform: uppercase;
}

.careers-navigation-block__sub-nav-menu {
  color: #6D6D6D !important;
  background-color: #ffffff !important;
}

.careers-navigation-block__menu-section--center > div > div > .careers-navigation-block__menu-item > div {
  box-shadow: 0px 0px 10px -4px rgb(0 0 0 / 45%);
  overflow: hidden;
}

.careers-navigation-block__menu-item:hover,
.careers-navigation-block__sub-nav-menu:hover {
  color: #007EAC !important;
}

/* Update some of the styles to meet accessibility requirements */
.external-definition-list dt {
  color: #0078A3;
}

#js-careers-jobs-block,
.external-definition-list dd,
.external-definition-list dd 
.link--default,
.text-brand-ash-grey{
  color: #5c5c5c !important;
}

.external-button:focus, 
.external-button:active,
.link:focus,
.search__input:focus,
.filter .filter__button:focus {
  outline: 2px solid #2a8853 !important;
}

.external-button--theme-highlight:hover {
  background-color: #004f66;
}

.slick-dots li button:hover, .slick-dots li button:focus {
  outline: 1px solid #2a8853 !important;
}

/* Fix the placeholder colors */
input::placeholder,
.checkable-input__label,
.react-select .react-select__placeholder {
  color: #6F6F6F !important;
  opacity: 1;
}
    </style>


    




  

  <meta property="og:url" content="https://bathspa.pinpointhq.com/">
<meta property="og:type" content="website">
<meta property="og:locale" content="en_GB">
<meta property="og:title" content="Careers at Bath Spa University">
<meta property="og:description" content="Bath Spa University is where creative minds meet. Offering a wide range of courses across the arts, sciences, education, social science and business to over 7,500 students, the University employs outstanding creative professionals which support its aim to be a leading educational institution...">
<meta property="og:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@pinpointhq">
<meta name="twitter:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">

  <script nonce="b0ff7b091dbe2fd3786216f86048dbe6">
//<![CDATA[

    window.railsEnv = "production";

//]]>
</script>
  

    <link href="https://bathspa.pinpointhq.com/" rel="canonical" />
</head>

<body dir='auto' class="external-body pinpoint-page pinpoint-page--home theme-default">

  

  
  <style>
    :root {
      --theme-primary-color: #007eac;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #0078a3;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <style>
    @media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {
      .theme-primary-color-ie-override {
        color: #007eac !important;
      }
      .theme-primary-background-color-ie-override {
        background-color: #007eac !important;
      }
      .theme-primary-border-color-ie-override {
        border-color: #007eac !important;
      }
      .theme-secondary-color-ie-override {
        color: #F4F4F4 !important;
      }
      .theme-secondary-background-color-ie-override {
        background-color: #F4F4F4 !important;
      }
      .theme-secondary-border-color-ie-override {
        border-color: #F4F4F4 !important;
      }
      .theme-highlight-color-ie-override {
        color: #0078a3 !important;
      }
      .theme-highlight-background-color-ie-override {
        background-color: #0078a3 !important;
      }
      .theme-highlight-border-color-ie-override {
        border-color: #0078a3 !important;
      }
    }
  </style>


  <div class="external-content" id="external-content-body">


    






<main class="external-main">

  
    <section class="pinpoint-block pinpoint-block--navigation careers-block careers-navigation-block careers-navigation-block--justified theme-primary-background-color-ie-override" style="">

  <div class=" frow frow--gutters frow--justify-between frow--items-center frow--nowrap">

  <div class="careers-navigation-block__menu-section--left">
    <a style="display: block" href="/">

      <div class="frow frow--items-center frow--gutters">

        <span class="careers-navigation-block__logo-text" style="color: inherit">
          Careers at
        </span>

        <div class="hide-at-sm-block"><img alt="Bath Spa University - Home" style="width: 21.6px; height: 30.0px;" width="21" height="30" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lQTkRRd0xqQjROakF1TUFZNkJrVlUiLCJleHAiOm51bGwsInB1ciI6InZhcmlhdGlvbiJ9fQ==--a8aaf45d691ceff55bb4ecfcc9bec21f806890fa/BSU%20master%20logo.png" /></div><div class="hide-sm-block"><img alt="Bath Spa University - Home" style="width: 36.1px; height: 50.0px;" width="36" height="50" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lRTkRRd0xqQjRNVEF3TGpBR09nWkZWQT09IiwiZXhwIjpudWxsLCJwdXIiOiJ2YXJpYXRpb24ifX0=--5fd990b5737f041b8b006e0f6f8b9bd3043c9631/BSU%20master%20logo.png" /></div>

      </div>

</a>  </div>

  <div class="careers-navigation-block__menu-section--center">

    <script type="application/json" id="js-react-on-rails-context">{"railsEnv":"production","inMailer":false,"i18nLocale":"en","i18nDefaultLocale":"en","rorVersion":"13.0.2","rorPro":false,"href":"https://bathspa.pinpointhq.com/","location":"/","scheme":"https","host":"bathspa.pinpointhq.com","port":null,"pathname":"/","search":null,"httpAcceptLanguage":null,"serverSide":false}</script>
<div class="careers-navigation-overflow-menu" style="" id="External::Careerspage::Responsivenavigation-react-component-c64ce509-9507-44ef-8eea-17fbbb1d3dd9"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Responsivenavigation" data-dom-id="External::Careerspage::Responsivenavigation-react-component-c64ce509-9507-44ef-8eea-17fbbb1d3dd9">{"menuItems":[],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

  <div class="careers-navigation-block__menu-section--right">

      <a class="careers-navigation-block__menu-item" style="" href="/?scroll_to=js-careers-jobs-block">View Jobs</a>

  </div>

</div>


</section>


    <section class="pinpoint-block pinpoint-block--hero careers-hero-block careers-hero-block--align-left careers-hero-block--image" style="background-color: #222222; color: #ffffff; background-image: linear-gradient(rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0.5)), url(https://res.cloudinary.com/pinpointhq/image/upload/f_auto,q_auto/v1/uploads/production/h9mzkgn15hekkvcjcydg);">



      <div class="external-content-wrap careers-hero-block__content-wrap">

        <div class="careers-hero-block__content">

          <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-hero-block__title">Work at Bath Spa University</h2>
            <p class="careers-hero-block__text">Our purpose is to challenge our staff and students to realise their talent and thrive.</p>

          </div>

            <div>
              <a aria-label="" class="external-button external-button--theme-primary mar-b-5 mar-sm-b-10 theme-primary-background-color-ie-override theme-primary-border-color-ie-override" href="#js-careers-jobs-block">View Jobs</a>
            </div>

        </div>

      </div>


</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Our values</h2>

            <div class="careers-block__trix external-panel text-center"><div>At Bath Spa we recognise that equality, diversity and inclusion are essential to building the creative, innovative and nurturing ethos that we pride ourselves on. That’s why <strong>Inclusion</strong> forms one of our four core cultural values alongside <strong>Respect</strong>, <strong>Collaboration </strong>and <strong>Sustainability</strong>.</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--video careers-block">

  <div class="external-content-wrap">

    <div id="External::Careerspage::Video-react-component-b500b012-21b9-4733-aaef-8e6256221108"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Video" data-dom-id="External::Careerspage::Video-react-component-b500b012-21b9-4733-aaef-8e6256221108">{"provider":"youtube","videoId":"https://www.youtube.com/embed/oMniClzyzpI?si=64E94e2XuaBamGkj","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-1 careers-card-block careers-card-block--align-left careers-card-block--variant-large">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-sm-7-12 col-sm-order-1 col-order-2">

        <div class="careers-card-block__content">

          
          <h3 class="careers-card-block__h3">Why apply to Bath Spa University?</h3>
          <div class="careers-card-block__p "><div>We are the UK's university of choice for creativity, culture, enterprise and education, and are home to students and staff from over 80 countries. The University is committed to recruiting and retaining the highest quality staff.<br><br>We provide an environment that respects and celebrates all members of our community, and is free from discrimination, prejudice, harassment and bullying. So much so, we are proud to have a wide range of staff networks set-up to foster diversity and inclusion here at Bath Spa. <br><br>These include:</div><ul>
<li>BathSpa+ (for our LGBTQIA+ Staff) </li>
<li>Disabled Staff Network</li>
<li>Women's Staff Network </li>
<li>Neurodiversity Staff Network </li>
<li>Parent and Carers Network </li>
<li>Global Inclusivity Network for staff who identify as Black, Asian, mixed race, or another minoritised ethnicity. </li>
</ul><div>We also have a Staff Equalities Network for colleagues interested in activism and enacting change at a grassroots level.<br><br>These are some of the fab reasons why 82% of our staff said they would recommend us to a friend as a good employer in the last staff survey.<br><br>Carry on scrolling for more great reasons...</div></div>
          

        </div>

      </div>


        <div class="col-sm-5-12 col-sm-order-2 col-order-1">

            <img class="careers-card-block__image cld-responsive" alt="" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,q_auto,w_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /><noscript><img class="careers-card-block__image" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /></noscript>


        </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--image-gallery careers-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div id="External::Careerspage::Imagegallery-react-component-35b016a3-7c31-4401-b866-5ca603b55207"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Imagegallery" data-dom-id="External::Careerspage::Imagegallery-react-component-35b016a3-7c31-4401-b866-5ca603b55207">{"cloudinaryImages":[{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/lpwat6i2mpwpgzkomc68","width":5332,"height":3552,"alt":"","publicId":"uploads/production/lpwat6i2mpwpgzkomc68"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/gxj4mi4kl0oxer7wdwgi","width":1000,"height":1000,"alt":"","publicId":"uploads/production/gxj4mi4kl0oxer7wdwgi"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/otke5vlkmrg6a5gp0hxl","width":1000,"height":1500,"alt":"","publicId":"uploads/production/otke5vlkmrg6a5gp0hxl"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/iqzgcwcu2zr0358ckf37","width":7952,"height":5304,"alt":"","publicId":"uploads/production/iqzgcwcu2zr0358ckf37"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/toiyerugdnkgji0dsfyh","width":5125,"height":3417,"alt":"","publicId":"uploads/production/toiyerugdnkgji0dsfyh"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/zrw1nruistevzollfwuu","width":5760,"height":3840,"alt":"","publicId":"uploads/production/zrw1nruistevzollfwuu"}],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Benefits</h2>

            <div class="careers-block__trix external-panel text-center">We work hard, but we also know you have a family, friends, hobbies, and a life outside the office. That’s why we offer a great benefits package, not just a competitive salary.</div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /></noscript>
          <h3 class="careers-card-block__h3">41 days holiday</h3>
          <div class="careers-card-block__p "><div>This includes bank holidays and University closure days. Everyone needs a healthy, happy, and productive life. This means you'll need time to rest and recover.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /></noscript>
          <h3 class="careers-card-block__h3">Generous pension plans</h3>
          <div class="careers-card-block__p "><div>We've got you covered for the future. Work in the comfort of knowing that all your hard work is not only paying off now but also setting you up for the future.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /></noscript>
          <h3 class="careers-card-block__h3">Flexible working</h3>
          <div class="careers-card-block__p "><div>We know life is busy so, where we can, we support flexible working to ensure our teams are happy, productive and listened to.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /></noscript>
          <h3 class="careers-card-block__h3">Onsite nursery </h3>
          <div class="careers-card-block__p "><div>Reduce the morning stress by dropping the kids off at the onsite nursery. We've got you and your family covered.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /></noscript>
          <h3 class="careers-card-block__h3">Employee assistance programme </h3>
          <div class="careers-card-block__p "><div>We've teamed up with Telus Health to provide you with extra support when needed. Whether it is health, family, money, work or yourself, Telus Health is only a phone call away.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /></noscript>
          <h3 class="careers-card-block__h3">A team that cares</h3>
          <div class="careers-card-block__p "><div>You’ll be joining a team of smart, capable, helpful people that want you to win, our students to win and our University and community to grow. Not to mention our team of care dogs who are on hand to put a smile on your face if needed.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--column-start ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-left">We asked our teams...</h2>

            <div class="careers-block__trix external-panel text-left"><div>"Beyond pay and benefits, what things make Bath Spa a great place to work?"</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--carousel careers-block careers-carousel-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


      <div id="External::Careerspage::Carousel-react-component-9060d3d0-c1da-4ae3-8e50-9435b83e7a7c"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Carousel" data-dom-id="External::Careerspage::Carousel-react-component-9060d3d0-c1da-4ae3-8e50-9435b83e7a7c">{"renderedBlocks":["\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The sense of community, my colleagues, the students, the campus, the general atmosphere of positivity and appreciation.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Sarah \n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;A culture that support equal access for staff and students.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Meg\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;Beautiful campus with the opportunity to learn new things from those around us. Also,\na good team working atmosphere where team members are willing to help and support each other. Cultivating a fun, happy and hard-working culture where everyone feels valued.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Simon\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The people are wonderful - their values are ones I agree with and try to live by.\n\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Suman\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e"],"autoplay":false,"autoplaySpeedMs":10000,"showDots":true,"infinite":true,"scrollAmount":1,"showAmount":1,"scrollSpeedMs":500,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

</div>
</section>


    <section class="pinpoint-block pinpoint-block--jobs careers-block" id="js-careers-jobs-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <h2 class="careers-block__h2 text-center">Current Opportunities</h2>

      <div class="careers-block__content pad-b-3">

        <div class="frow frow--gutters frow--gutters-md-2x frow--items-end">

          <div class="col-flex-grow-1">

            <form role="search">
              <button type="submit" disabled style="display: none" aria-hidden="true"></button>
              <div id="Shared::Search-react-component-fa97ae24-ba89-4ef3-b9b7-7b120e8ae08e"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="Shared::Search" data-dom-id="Shared::Search-react-component-fa97ae24-ba89-4ef3-b9b7-7b120e8ae08e">{"target":"external:jobs:index:5494","willUpdateUrl":true,"searchPlaceholderText":"Search...","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      

            </form>

          </div>


            <div class="col-md-6-12">
              <div id="External::Filters-react-component-77078c51-9e9c-425d-b8f6-8de152be02fb"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Filters" data-dom-id="External::Filters-react-component-77078c51-9e9c-425d-b8f6-8de152be02fb">{"filters":[{"name":"location","attribute":"location_id","values":[],"items":[{"label":"Bath","value":10393},{"label":"Bath - Corsham Court","value":14961},{"label":"Bath - Locksbrook Campus","value":14959},{"label":"Bath - Newton Park","value":14958},{"label":"Bath - Newton Park \u0026 Locksbrook","value":14962},{"label":"Bath - Palace Yard Mews","value":17471},{"label":"Bath - Sion Hill Campus","value":14960},{"label":"Bath Spa University London","value":23470},{"label":"London - New City College ","value":14963},{"label":"Remote","value":27327},{"label":"The Studio - Palace Yard Mews","value":26635},{"label":"Various - Across SW England ","value":28564}],"translations":{"singleItem":"Location","pluralItems":"Locations","allItems":"All Locations"}},{"name":"department","attribute":"department_id","values":[],"items":[{"label":" Innovation and Knowledge Exchange Centre","value":37689},{"label":"Academic Planning","value":19086},{"label":"Art, Film \u0026 Media ","value":41507},{"label":"Bath Business school - London ","value":34431},{"label":"Bath School of Music and Performing Arts ","value":31904},{"label":"Bath Spa University London ","value":29962},{"label":"Business School","value":19085},{"label":"Careers and Employability","value":28533},{"label":"Catering ","value":34135},{"label":"Centre for Educational Partnerships ","value":38139},{"label":"Chancelry","value":25472},{"label":"Data \u0026 Insights Service","value":33104},{"label":"EAU","value":32064},{"label":"EAU Short Courses","value":29808},{"label":"Estates","value":25473},{"label":"Estates and Services","value":30675},{"label":"Estates/Security","value":30951},{"label":"External Affairs Unit","value":25474},{"label":"Facilities and Services","value":30050},{"label":"Finance","value":25475},{"label":"Future Students","value":31406},{"label":"Governance \u0026 Engagement ","value":35154},{"label":"Governance Legal \u0026 Compliance","value":25476},{"label":"HR","value":19087},{"label":"IT Services","value":25477},{"label":"Learning Innovation \u0026 Skills Unit /  Schools Technical Services","value":34216},{"label":"Learning, Innovation and Skills","value":36124},{"label":"Learning, Innovation and Skills: Academic Skills","value":28307},{"label":"Library and Learning Services","value":28326},{"label":"Marketing and Applicant Comms, Future Students ","value":29815},{"label":"Portfolio and Planning","value":30409},{"label":"Research \u0026 Enterprise","value":25478},{"label":"Research \u0026 Graduate Affairs","value":33220},{"label":"School Of Science","value":29645},{"label":"School of Art, Film \u0026 Media","value":36272},{"label":"School of Design","value":19088},{"label":"School of Education","value":25479},{"label":"School of Film \u0026 Arts","value":19084},{"label":"School of Music \u0026 Performing Arts","value":19083},{"label":"School of Science","value":29646},{"label":"School of Sciences","value":25480},{"label":"School of Writing Publishing \u0026 Humanities","value":25481},{"label":"School of Writing, Publishing and the Humanities","value":29246},{"label":"Strategic Projects \u0026 Delivery Unit","value":25482},{"label":"Strategic Projects and Change Unit","value":36037},{"label":"Student Accommodation ","value":35035},{"label":"Student Experience","value":25483},{"label":"Student Housing ","value":33411},{"label":"Student Wellbeing SErvices","value":31929},{"label":"Student Wellbeing Services ","value":28279},{"label":"Student and Registry Services","value":29262},{"label":"Student wellbeing Services","value":31930},{"label":"Technical Services","value":30746},{"label":"Wellbeing \u0026 Disability","value":30147},{"label":"Writing, Publishing \u0026 Humanities ","value":29781}],"translations":{"singleItem":"Department","pluralItems":"Departments","allItems":"All Departments"}}],"isUrlFilterable":true,"target":"external:jobs:index:5494","willUpdateUrl":true,"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


            </div>


        </div>

      </div>

    </div>

  </div>


  <div id="External::Jobs-react-component-132ba702-7331-4e67-a2f9-ea4da0935458"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Jobs" data-dom-id="External::Jobs-react-component-132ba702-7331-4e67-a2f9-ea4da0935458">{"additionalColumns":[],"url":"/postings.json","target":"external:jobs:index:5494","translations":{"job_title":"Job Title","department":"Department","division":"Division","requisition_id":"Requisition ID","structure_custom_group_one":"Custom","location":"Location","employment_type":"Employment Type","no_positions":"There are currently no positions advertised.","no_opportunities":"There are currently no opportunities based on your filters. Please try again, or register your interest.","workplace_type":"Workplace type"},"structures":[{"key":"location","keyPlural":"locations","name":"Location","namePlural":"Locations","nameAccessor":"locationName","columnVisibilityAccessor":"locationsColumnVisible"},{"key":"department","keyPlural":"departments","name":"Department","namePlural":"Departments","nameAccessor":"departmentName","columnVisibilityAccessor":"departmentsColumnVisible"}],"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"showPagination":false,"pageSize":null,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      



</section>



</main>


  </div>

    <footer class="external-footer theme-secondary-background-color-ie-override" id="external-content-footer">

  <div class="external-content-wrap">


    <div class="external-footer__content">

      <div class="frow frow--justify-between frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-3x">

        <div>

          <div class="frow frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-2x">


              <a class="external-footer__link" target="_blank" href="https://www.bathspa.ac.uk/">

                Bath Spa University <i class="fas fa-external-link-alt mar-l-1"></i>

</a>

            <a class="external-footer__link" target="_blank" href="/themes/2198/privacy_policy">
              Privacy Policy
</a>
              <a class='external-footer__link' data-cc="c-settings" aria-label="View cookie settings" tabindex="0" role="button">
                Cookies
              </a>

            <div class="frow frow--gutters frow--items-center">
              <a class="external-footer__link" href="https://www.facebook.com/bath.spa.university" target="_blank" title="Bath Spa University&#39;s Facebook page." style="margin-right: 5px;"><i class="fab fa-facebook fa-lg" style="color: #3B5998"></i></a>
              
              
              
              <a class="external-footer__link" href="https://www.instagram.com/bathspauni" target="_blank" title="Bath Spa University&#39;s Instagram page." style="margin-right: 5px;"><img alt="Bath Spa University instagram" src="https://d2n5ied94mazop.cloudfront.net/packs/static/logos/external/instagram_logo-5139d56ff0927cddd11f.svg" /></a>
              
            </div>

          </div>

        </div>

        <div>

          <a class="external-footer__link" target="_blank" href="https://www.pinpointhq.com">Powered by Pinpoint</a>

        </div>

      </div>

    </div>

  </div>

  </div>

</footer>


  







    <script nonce="b0ff7b091dbe2fd3786216f86048dbe6">
  // Ensures that the stuff in the iframe doesn't take focus
  setTimeout(() => {
    var frames = document.getElementsByTagName("iframe");
    for (i = 0; i < frames.length; ++i) {
      frames[i].setAttribute("tabindex", "-1");
    }
  }, 1000)
</script>


</body>

+  recorded_at: Tue, 30 Jul 2024 16:28:00 GMT
 - request:
     method: get
     uri: https://bathspa.pinpointhq.com/postings.json
@@ -91,7 +91,7 @@ http_interactions:
       Server:
       - nginx
       Date:
-      - Thu, 27 Jun 2024 13:37:18 GMT
+      - Tue, 30 Jul 2024 16:28:00 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -109,28 +109,28 @@ http_interactions:
       Referrer-Policy:
       - strict-origin-when-cross-origin
       Etag:
-      - W/"9b23b493b77beb71284ae1fca68fad41"
+      - W/"c3895cb326a9f84f779ffcc4c4db08f3"
       Cache-Control:
       - max-age=0, private, must-revalidate
       Content-Security-Policy-Report-Only:
       - 'default-src ''self'' https:; font-src ''self'' https: data:; img-src ''self''
         https: data:; object-src ''none''; media-src ''self'' https: blob:; script-src
-        ''self'' https: ''strict-dynamic'' ''nonce-3c9e0084f25f3633b3b6696338d90389'';
+        ''self'' https: ''strict-dynamic'' ''nonce-404e7ff78ccc3fd9f746f6c6042f8ddb'';
         style-src ''self'' https: ''unsafe-inline''; connect-src ''self'' https: wss:;
         base-uri ''none''; report-uri /csp_violation_reports'
       Set-Cookie:
-      - LSW_WEB=LSW_WEB8; path=/
-      - _pinpoint_session=CUqVUSfxDTdpg4Ehy56FcmWyL54Vrr6BTlHNgwUWuHlLH3Kt198%2FDa6GJE0kqy7W85G23EG7JKnXY1ne2RyjF0pYy28OtsRqMXFvQtN4J9bu0Vb3BvM4PvmGYSp21GGe%2BX4gLZQ71CmHP42bKsLsTmDDvSPfLd7m4ghFB7tLT0%2F0j%2BLkzler4C9jQFKlHgb2YkTYYiQzMIeBCHYvJKGIUpnMlC9PHliL4LKxP1%2Bl7hnrPNq%2FjxPtSfI4NJlIq4iE55tmurhooW5Rs9HbtuSgkO98nTNQ3RH5eC%2FsFJEk8tgQ9%2BA%3D--QhnuEmHEvy6Z6iGp--n6qNSJzMHWU2j4xtFVTNrg%3D%3D;
-        domain=.pinpointhq.com; path=/; expires=Thu, 04 Jul 2024 13:37:18 GMT; secure;
+      - LSW_WEB=LSW_WEB3; path=/
+      - _pinpoint_session=LXd4Y0IYyWSu6uVnCBiLTEzOFSSWA0lGqdtF5WwgpawIwc7N2%2B8mPgmsJRHUsaH1ZULoSG7WRxj00DrRSWlj1MKNbotqwo9CYv%2FyMGpPS%2BlFcaEO0h%2BMsMPHVJdZAfguLOSzVeZBXA7zaFStHdUxdFoxXrbmwDkH3XrBRHX2GF4wrd4bKqSEH2GGFzvXqqaXa3q54oFgUxx6CBGXjRqQ0MY3BZKKwOrPgqRNN3BxpcVMDDhvzmz66eZwpdbtJjMBxNTOa%2FB0WqjcLh7QHmAfmiLsvc58Bxiukt6KkkcLe2EZAE8%3D--qiEYIWeSddUeawuT--52jSlAXmezhCo5RZIaSxqQ%3D%3D;
+        domain=.pinpointhq.com; path=/; expires=Tue, 06 Aug 2024 16:28:00 GMT; secure;
         HttpOnly; SameSite=None
-      - ahoy_visit=ca5bb5ae-6563-420d-a259-6a9ed2e91422; path=/; expires=Thu, 27 Jun
-        2024 17:37:17 GMT; secure
-      - ahoy_visitor=16e4eea9-6d05-447e-aff9-e9d1785ba32e; path=/; expires=Sat, 27
-        Jun 2026 13:37:17 GMT; secure
+      - ahoy_visit=570b2892-f293-43d4-89be-9f8377ac325b; path=/; expires=Tue, 30 Jul
+        2024 20:28:00 GMT; secure
+      - ahoy_visitor=5101fa80-f9ef-48f1-a47c-9a4eed188251; path=/; expires=Thu, 30
+        Jul 2026 16:28:00 GMT; secure
       X-Request-Id:
-      - 3a0bdf12-0427-4628-83eb-156c91fbfaac
+      - 69c210f5-f38c-4ccc-bab9-5e6c91042b67
       X-Runtime:
-      - '0.322591'
+      - '0.253067'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Vary:
@@ -140,11 +140,11 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"data":[{"id":"185104","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThe Music facilities are first class: in addition to our 50+ Apple Mac workstations (all equipped with Pro Tools, Logic Pro etc) we have high-quality studios with state-of-the-art equipment including SSL and Neve large format consoles, Dalby ATMOS enabled audio-visual spaces and high spec production suites. Our curriculum provides a solid foundation for the music and creative industries and includes songwriting, music production, live performance, touring, digital marketing, video production business and research skills.\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor more information on our approach and to see what our graduates are doing please visit:\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cul\u003e\u003cli\u003e\u003c!--block--\u003e\u003ca href=\"https://cmgrads.wordpress.com\"\u003e\u003cstrong\u003ehttps://cmgrads.wordpress.com\u003c/strong\u003e\u003c/a\u003e\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003e\u003ca href=\"https://www.bathspa.ac.uk/courses/?keyword=commercial+music\"\u003e\u003cstrong\u003ehttps://www.bathspa.ac.uk/courses/?keyword=commercial+music\u003c/strong\u003e\u003c/a\u003e\u003c/li\u003e\u003c/ul\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cbr\u003eThis is a full-time role with the potential to job share.\u003cbr\u003e\u003cbr\u003eSalary: Grade 8, £42,978 to £54,395 \u003cbr\u003e\u0026nbsp;\u003cbr\u003eInterview: Monday 15th July\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £54,395 / year","compensation_minimum":42978.0,"compensation_maximum":54395.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-01T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eThe Commercial Music course at Bath Spa University is seeking a dedicated Lecturer/Senior Lecturer in Commercial music with a focus on music production. (Full time role with potential to job share)\u0026nbsp;\u003c/div\u003e","employment_type":"permanent_full_time","employment_type_text":"Permanent - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe Commercial Music subject area has around 180 students, with widely varying musical interests across the undergraduate and postgraduate programmes. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou’ll play a direct role in curriculum development, teaching and assessment on the BA Commercial Music and our MA Commercial Music, which has a specialist production pathway.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis is a full-time role, but as we are seeking an individual with a strong industry profile, we recognize that you may wish to combine your teaching role and practice, to facilitate this, we are offering this role as a potential job share.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have a proven track record at a professional level combined with the desire and skills to translate that experience into their teaching practice. You will have ‘classic’ live recording/engineering and mixing skills, as well as an ‘in the box’ songwriter/producer approach.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eAdditional skills that would be beneficial could include live performance, songwriting, music for media and audio-visual performance/presentation.\u0026nbsp; You will have a strong interest in pedagogy and the ability to relate that to a wide range of musical styles and genres at undergraduate and postgraduate levels. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou may have or be working towards a post-graduate qualification, and you will be in a position to make an effective contribution to enhancing Commercial Music’s already strong links with industry. In addition, you will be an inspiring and engaging communicator, a team player, an effective organiser and a skilled networker.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Lecturer / Senior Lecturer Commercial Music ","url":"https://bathspa.pinpointhq.com/en/postings/b27f5ada-9c13-49f9-b391-fb823dc151ce","path":"/en/postings/b27f5ada-9c13-49f9-b391-fb823dc151ce","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"203597","requisition_id":"261_23_24","department":{"id":"19083","name":"School of Music \u0026 Performing Arts"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"187565","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eSalary:\u003c/strong\u003e \u003cstrong\u003e£12.00 per hour.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis is a casual role and hours will be agreed on appointment.\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£12.00 / hour","compensation_minimum":12.0,"compensation_maximum":12.0,"compensation_currency":"GBP","compensation_frequency":"hour","compensation_visible":true,"deadline_at":"2024-07-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are looking for reliable and committed individuals to work as part of the Facilities and Services team to maintain clean and safe environments at our campuses. The role will also require linen management and distribution as required. Our team prides ourselves on our positive ‘can do’ approach towards supporting our students, staff and visitors.\u0026nbsp; \u0026nbsp;\u003c/div\u003e","employment_type":"part_time","employment_type_text":"Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eLinen Management and Distribution, cleaning and supporting summer schools and conferences as required.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eCleaning/Linen Management experience is beneficial but what we’re looking for most is reliability, attention to detail and a willingness to learn.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Cleaner/Linen Coordinator (casual role)","url":"https://bathspa.pinpointhq.com/en/postings/777c2594-4859-4b56-9b34-a032b0229030","path":"/en/postings/777c2594-4859-4b56-9b34-a032b0229030","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"206007","requisition_id":"","department":{"id":"30050","name":"Facilities and Services"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"188584","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis permanent, full-time opportunity is to support students in their work primarily working Monday to Friday, with some evening and weekend work required during term time.\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eTo discuss further and for more information about the role please contact Richard Wood \u003c/strong\u003e\u003ca href=\"mailto:r.wood@bathspa.ac.uk\"\u003e\u003cstrong\u003er.wood@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e , TV Studios Manager.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eSalary: Grade 6, £32,332 to £36,024\u0026nbsp;\u003cbr\u003e\u003cbr\u003eInterviews: 17/07/2024\u0026nbsp;\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e \u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship and your application will automatically be rejected.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£32,332 - £36,024 / year","compensation_minimum":32332.0,"compensation_maximum":36024.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-10T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking a Technical Demonstrator in Sports Media Production to join our team of Technical Demonstrators in delivering demonstrations of specialist technical equipment, resources, and techniques to our students as part of our brand-new BA (Hons) in Sports Media Production course based at our Newton Park campus.\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role of a Technical Demonstrator combines technical knowledge and innovative thinking with the design and delivery of hardware and software demonstrations to students. You will work closely with the academic staff who deliver the teaching within the School of Art, Film and Media and be part of a wider team of Technical Demonstrators and Technicians who provide support for courses across the whole university.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will be responsible for developing, preparing, and running demonstration workshops for groups of students and others using the workspace, and you will supervise students using workshop facilities for project work on location i.e sports grounds as well as on site.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eIn addition, you will also be responsible for the Health and Safety compliance in all respects for the working environment for those using the workshop facilities, including risk assessments. Maintenance and repair of equipment, and upkeep within the workshop and resources related to the subject will also an integral part of this role.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have significant practical skills and knowledge as well as previous demonstration or training experience in commercial film, television or educational setting with sports broadcast experience welcomed. Up to date knowledge of professional equipment and techniques including single camera film making, postproduction editing and motion graphics as well as multi camera television production so a working knowledge of camera, lighting, audio recording and editing techniques is essential.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will be passionate about keeping up to date with new ideas, equipment, and techniques in video production to create engaging content for audiences interested in sport.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will also have excellent communication skills with the ability to liaise with other staff, students, departments, and external organisations is essential, along with the ability to work well as part of a team and will manage your own time with limited supervision. This is a busy and diverse role so an ability to respond flexibly and reliably to complex workloads, prioritising conflicting demands is essential. Previous experience in teaching or demonstration in a higher educational setting is desirable, but not essential.\u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Technical Demonstrator (Sports Media Production)","url":"https://bathspa.pinpointhq.com/en/postings/48f9fb18-a941-4f47-a7cd-bb72e1572ed7","path":"/en/postings/48f9fb18-a941-4f47-a7cd-bb72e1572ed7","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"207031","requisition_id":"284_23_24","department":{"id":"36124","name":"Learning, Innovation and Skills"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"189486","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eInterview date Thursday 18th July 2024\u003cbr\u003e\u003cbr\u003eGrade Ac3S - Ac3A\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £54,395 / year","compensation_minimum":42978.0,"compensation_maximum":54395.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-07T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking a Lecturer/Senior Lecturer in Forensic Science to design and deliver teaching content in the classroom and laboratory, across a range of modules in various Programmes within the Biological Sciences Subject area, with particular emphasis on Forensic Science techniques and skills.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role will lead the curriculum planning and development of a new BSc Forensic Science programme, which launches in September 2024.\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe post holder will be expected to contribute to undergraduate teaching across levels 4-6 in Biological Sciences, particularly in areas related to Forensic Science. The role will have key involvement in the delivery and ongoing development of the new Forensic Science BSc. There will be associated module administration such as assessment, marking and feedback.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe role also involves acting as an Academic Advisor to undergraduate students and supervising final year Dissertation projects. There will also be involvement in the promotion and marketing of the Forensic Science course.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eWe are looking for someone with recent, successful experience of university teaching in core areas of Forensic Science, who understands the importance of providing students with an excellent learning experience throughout their studies.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eIdeally this would include experience of leading modules and developing the curriculum within multidisciplinary courses. We would be particularly interested in candidates with experience of the professional frameworks and accreditation of Forensic Science Programmes. \u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Senior Lecturer/Lecturer in Forensic Science","url":"https://bathspa.pinpointhq.com/en/postings/888f7b29-82b8-4892-923b-79ed00095fa7","path":"/en/postings/888f7b29-82b8-4892-923b-79ed00095fa7","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"207915","requisition_id":"305/23/24","department":{"id":"25480","name":"School of Sciences"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"189563","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 6 - £32,332 - £36,024 per annum\u003cbr\u003e\u003cbr\u003eInterviews are expected to be at the beginning of August\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£32,332 - £36,024 / year","compensation_minimum":32332.0,"compensation_maximum":36024.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-14T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;Come join our growing team at Bath Spa University in London! This is an exciting opportunity to contribute to the professional success of our students and graduates in a vibrant and innovative learning environment. The role is based at our new, business-focussed teaching centre based in vibrant Hackney, East London and is easily accessible via Hoxton and Shoreditch overground stations, as well as the bus and tube.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe new centre enjoys top facilities, friendly academic and student support teams and a great location that equips our students with the knowledge, opportunities, and skills needed for a successful career. With the recent development of the Postgraduate Business Education academic portfolio at BSUL we will be welcoming our first cohort of sponsored international students from September 2024 in addition to our foundation year and undergraduate programmes.\u0026nbsp;\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;As an Employability Coach you will support students and recent graduates to navigate their future careers with confidence by designing and facilitating group workshops and through individual coaching. You will be working with diverse student groups including international students, non\u0002native English speakers and mature students.\u003cbr\u003e\u003cbr\u003eUsing your understanding of the employability needs of these groups, and key employability data, you will be strategic in your approach to providing impactful initiatives which enable successful outcomes. You will work closely with colleagues across Careers and Employability, Student Experience and with academic colleagues to provide professional development opportunities that enhance career readiness and progression.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;We are looking for someone who is energised by working with learners from diverse groups to develop their skills and progress into successful careers. With experience of designing and delivering career education workshops and resources and supporting students through one-to-one guidance and coaching, you will be able to use data insights to shape provision and maximise impact.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis is a new role and as such you will need be a confident self-starter who possesses initiative, can manage multiple priorities, and is self-driven. You will have a collaborative mindset and be able to manage ambiguity, welcoming change as we adapt and grow with new student populations and courses.\u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Employability Coach (London \u0026 International Students)","url":"https://bathspa.pinpointhq.com/en/postings/d3e80317-6a56-461f-8b74-b189f265de15","path":"/en/postings/d3e80317-6a56-461f-8b74-b189f265de15","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"207990","requisition_id":"257/23/24","department":{"id":"28533","name":"Careers and Employability"},"division":null,"structure_custom_group_one":null},"location":{"id":"23470","city":"London","name":"Bath Spa University London","province":"Bath"}},{"id":"189884","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 6 - £32,332 - £36,024 per annum\u003cbr\u003e\u003cbr\u003eInterviews are expected around the beginning of August\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£32,332 - £36,024 / year","compensation_minimum":32332.0,"compensation_maximum":36024.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-14T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;Come join our growing team at Bath Spa University in London! This is an exciting opportunity to build sustainable and mutually beneficial relationships with employers across London who can offer excellent professional experiences and graduate employment opportunities for our students and graduates. \u003cbr\u003e\u003cbr\u003eThe role is based at our new, business-focussed teaching centre based in vibrant Hackney, East London and is easily accessible via Hoxton and Shoreditch overground stations, as well as the bus and tube. The new centre enjoys top facilities, friendly academic and student support teams and a great location that equips our students with the knowledge, opportunities, and skills needed for a successful career.\u0026nbsp;\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking someone who can source new employer contacts using a variety of research and networking methods to support the wide variety of student and recent graduate populations from both our Bath and Hackney campuses and their courses. \u003cbr\u003e\u003cbr\u003eYou will be the first point of contact for our employer contacts in London, to understand their needs and be able to promote the many ways that they can engage with our talented students. We want to significantly grow our volume of London based placement and work-based learning opportunities with businesses of all sizes and sectors, including freelance opportunities. \u003cbr\u003e\u003cbr\u003eYou will need to develop a strong understanding of the employability needs of students studying at our BSUL London campus, who are predominantly international and studying postgraduate degrees\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eWe are looking for someone that is an excellent networker, who can engage with employers, colleagues and students to build mutually beneficial partnerships for the long term. The ability to analyse data that leads to insights and prioritisation of needs will be an essential skill for this role. \u003cbr\u003e\u003cbr\u003eA knowledge of the Greater London labour market for early career graduates would be desirable. You will be self-motivated and able to work well within and across multi-disciplinary teams based in Bath and London.\u003cbr\u003e\u003cbr\u003e\u0026nbsp;As we grow our student population and courses in London you will need to be adaptable and resilient to change and be confident in suggesting new ideas and promoting continuous improvements that benefit our students\u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Employer Relationships Adviser (London)","url":"https://bathspa.pinpointhq.com/en/postings/3a4d8418-5f73-4642-87a3-10444fbed31c","path":"/en/postings/3a4d8418-5f73-4642-87a3-10444fbed31c","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"208314","requisition_id":"257/23/24","department":{"id":"28533","name":"Careers and Employability"},"division":null,"structure_custom_group_one":null},"location":{"id":"23470","city":"London","name":"Bath Spa University London","province":"Bath"}},{"id":"189996","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePart Time Fixed Term Contract until End of July 2025 (Maternity Cover)\u003cbr\u003e\u003cbr\u003e29.6 hours per week, Monday - Thursday\u0026nbsp;\u003cbr\u003e\u003cbr\u003eGrade 5 £22,383 - £25,116 pro rata £27,979 - £31,396 per annum \u003cbr\u003e\u003cbr\u003eInterview Date - Friday 2nd August\u003cbr\u003e\u003cbr\u003e\u003c/strong\u003e\u003cstrong\u003e\u003cem\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003e\u0026nbsp;\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship and your application will automatically be rejected.\u0026nbsp;\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£27,979 - £31,396 / year","compensation_minimum":27979.0,"compensation_maximum":31396.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-27T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking a Student Information Officer who will be responsible for responding to enquiries, supporting the student body, and delivering exceptional customer services to students, staff, and visitors.\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003e(This is a Part Time Fixed Term Contract until End of July 2025 (Maternity Cover)\u003c/strong\u003e\u003c/div\u003e","employment_type":"fixed_term_part_time","employment_type_text":"Fixed Term - Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs a Student Information Officer, you will provide a professional front of house service, offering guidance and support on a number of areas and Registry processes, whilst maintaining student records. The role is a fixed term, maternity cover and will be based at the Newton Park campus.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eAs well as providing an approachable, friendly, and informative service to the student body, key responsibilities include data entry, processing withdrawal requests, updating the University record system (SITS), and working collaboratively with colleagues from across the university by supporting all major Student and Registry Services activities e.g., graduation ceremonies, registration and enrolment periods, and welcome activities.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be educated to degree level or equivalent work experience.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will be at ease dealing with a wide variety of people, in a customer service or support role.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eRecent experience of working in an administrative role including diligent record keeping, report writing and participation in teamwork is essential along with experience using Microsoft Office applications\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will possess excellent communication, interpersonal, and problem-solving skills and will work on own initiative and as part of a team. An understanding of and ability to observe confidentiality in all matters is crucial to this role along with the ability to plan and prioritise your work effectively.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor any further queries regarding this role, please contact Mary Humphries – Student Information Manager on \u003c/strong\u003e\u003ca href=\"mailto:m.humphries@bathspa.ac.uk\"\u003e\u003cstrong\u003em.humphries@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Part Time Student Information Officer - (Maternity cover) ","url":"https://bathspa.pinpointhq.com/en/postings/7cf482b6-bcb1-4378-87e9-4d988c46405f","path":"/en/postings/7cf482b6-bcb1-4378-87e9-4d988c46405f","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"208427","requisition_id":"296/23/24","department":{"id":"29262","name":"Student and Registry Services"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"190245","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eInterviews – 17th \u0026amp; 19th July\u003cbr\u003e\u0026nbsp;\u003cbr\u003eFor an informal discussion regarding this post, please contact Rachel Roberts 01225 876362\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003cstrong\u003e\u003cem\u003eWe reserve the right to close this vacancy early if we receive sufficient applications.\u0026nbsp;\u003cbr\u003eTherefore, if you are interested, please submit your application early.\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£32,332 - £36,024 / year","compensation_minimum":32332.0,"compensation_maximum":36024.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-07T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eAn exciting opportunity for a talented Head Chef to lead our team in bringing an innovative catering service that will set new standards of food excellence.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will lead our team in providing catering throughout the academic year for all Bath Spa University staff, students and visitors.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will also play a major part in our thriving conference and events business where catering is provided for summer schools, weddings, conferences and fine dining for VIP dinners.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eIf you are passionate and enthusiastic about food, have the drive and flair to help us shape and develop our catering department and have the vision to create modern, exciting, innovative and authentic food for Bath Spa University then we want to hear from you!\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003e\u0026nbsp;A calm, confident approach is essential, and you will flexible, forward thinking and have excellent customer service skills. In addition, you will also have a relevant Food Preparation qualification, an Intermediate Food Hygiene qualification and Allergen Awareness training from a recognised training provider.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Head Chef","url":"https://bathspa.pinpointhq.com/en/postings/3149f6fd-3b2a-4398-a10e-51edc3a3748b","path":"/en/postings/3149f6fd-3b2a-4398-a10e-51edc3a3748b","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"208663","requisition_id":"325/23/24","department":{"id":"34135","name":"Catering "},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"190264","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 5 £27,979 - £31,396 per annum\u003cbr\u003e\u003cbr\u003eInterviews - Around the 15th July. TBC\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003e\u003cem\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003e\u0026nbsp;\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship and your application will automatically be rejected.\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£27,979 - £31,396 / year","compensation_minimum":27979.0,"compensation_maximum":31396.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-07T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking a Student Success Officer for Student Life to join our dynamic team at our Hackney teaching site, Bath Spa University in London. This is an exciting opportunity to contribute to the holistic success of our students in a vibrant and innovative learning environment.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003ca href=\"https://www.bathspa.ac.uk/schools/bsu-london/\"\u003eBath Spa University London (BSUL)\u003c/a\u003e is our new, business-focused teaching centre based in vibrant Hackney, East London and is easily accessible via Hoxton and Shoreditch overground stations, as well as the bus and tube. The new centre enjoys top facilities, friendly academic guidance and a great location that equips our students with the knowledge, opportunities, and skills needed for a successful career. With the recent development of the Postgraduate Business Education academic portfolio at BSUL we will be welcoming our first cohort of sponsored international students from September 2024 in addition to our foundation year and undergraduate programmes.\u0026nbsp;\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs part of the Student Success Hub, you will play a pivotal role in community building and helping our diverse student body find the resources they need to be successful in their higher education journey. \u003cbr\u003e\u003cbr\u003eYou will coordinate events and communication, advise students on practical life and transition matters, and develop resources specific to our London campus.\u003cbr\u003e\u003cbr\u003eThough this position is based in London, you will work closely with Bath-based campuses to ensure the Campus Life provision at the London teaching site aligns with the larger student experience strategy of the university.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will bring previous experience in a student-facing or customer service-oriented role and will have a strong awareness and appreciation of cultural differences.\u0026nbsp; \u003cbr\u003e\u003cbr\u003eThis is a new role in a growing programme of diverse learners and as such you will need be agile, collaborative, curious and creative. You will be self-motivated and be able to work well within and across multi-disciplinary teams.\u003cbr\u003e\u003cbr\u003ePreferably, you will come with experience of coordinating student communication channels, event planning, and have a familiarity with the Hoxton/Hackney/Shoreditch area of London but this is not a requirement. If you bring the above skills and genuinely care about helping unique student populations reach their educational goals, we invite you to apply to become part of our team.\u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Student Success Officer - Student Life (London)","url":"https://bathspa.pinpointhq.com/en/postings/7b4176f1-e71f-4703-90f9-fe6a4fdebbb6","path":"/en/postings/7b4176f1-e71f-4703-90f9-fe6a4fdebbb6","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"208682","requisition_id":"263/23/24","department":{"id":"29962","name":"Bath Spa University London "},"division":null,"structure_custom_group_one":null},"location":{"id":"23470","city":"London","name":"Bath Spa University London","province":"Bath"}},{"id":"190599","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eSalary - Grade 4 - £25,138 - £27,181 per annum\u003cbr\u003e\u0026nbsp;\u003cbr\u003eInterview Date – 16th July 2024\u003cbr\u003e\u003cbr\u003e\u003c/strong\u003e\u003cstrong\u003e\u003cem\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003e\u0026nbsp;\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£25,138 - £27,181 / year","compensation_minimum":25138.0,"compensation_maximum":27181.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-07T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking a new HR Administrator to bring a fresh approach and positive energy to our efficient HR admin team.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs a core member of the HR department, you will take responsibility for supporting both non-academic and academic staff, which in turn plays a vital role in supporting our students.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eIn a vibrant and fast paced environment, you will be passionate about providing a smooth full HR administrative service which encompasses the employee life cycle, from issuing contracts to new starters to supporting leavers, you will act as an important point of contact for HR enquiries.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have strong administration skills and be able to communicate confidently with all levels of stakeholders across the University. You will demonstrate an ability to build relationships quickly and effectively, whilst being flexible and pro-active in your approach to work - as no two days will be the same. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eAs a crucial part of the role, you will have excellent accuracy, attention to detail and experience of dealing with confidential information and data. You will bring with you previous experience of managing electronic data and electronic filing systems along with a demonstrable knowledge of Google and Microsoft applications. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eAn understanding of the wider context of HR processes undertaken and the impact of HR administration is desirable but not essential as full training will be provided.\u0026nbsp; However, experience of working in a busy and varied administrative role is a key requirement of this role.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eSupport to undertake formal training and qualifications in HR would be provided if the successful candidate wishes to go down this route.\u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"HR Administrator ","url":"https://bathspa.pinpointhq.com/en/postings/5d8826e8-f35f-4fda-b757-6ae27fbf126a","path":"/en/postings/5d8826e8-f35f-4fda-b757-6ae27fbf126a","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"209024","requisition_id":"315/23/24","department":{"id":"19087","name":"HR"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"191078","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade - Ac3S/Ac3A - £ 42,978 - £54,395 per annum\u003cbr\u003e\u003cbr\u003eProvisional Interview Dates of 31st July \u0026amp; 2nd August\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £54,395 / year","compensation_minimum":42978.0,"compensation_maximum":54395.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-14T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking a Lecturer/ Senior Lecturer - Link Tutor in Business \u0026amp; Management, to work closely with other Link Tutors and academic colleagues.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eOur educational partner delivers our programmes in seven locations in England, to predominately non-traditional students. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe role is to ensure that our programme is delivered to the same high-quality standards as our programmes in Bath in terms of teaching delivery, assessment, student development and enhancement.\u0026nbsp; \u0026nbsp;\u0026nbsp;\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eActing as one of the first points of contact with the partner for all academic matters, you will monitor academic progress and provide oversight of academic standards.\u003cbr\u003e\u003cbr\u003eThe role will involve considerable travel to the different campus locations to meet staff and students to provide constructive support and promptly address any challenges which may arise.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will work to foster enhancement activities and work collaboratively with internal colleagues both in the Business School and more widely across the university.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role also encompasses various other activities as outlined in the job description, commensurate with the grade and scope of the position. \u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be an experienced business and management academic who will act as a full time Link Tutor for one of our large educational partners.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will have relevant qualifications and experience as a Link Tutor with an external partner, as an external examiner, or in an academic leadership role at an educational partner. You will have extensive knowledge and experience of teaching and learning in a relevant subject area within business and management and/or business law.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eCommitment to build and maintain professional relationships within the university and with the educational partner will be key, as will having the ability to inspire tutors and learners, mainly from non-traditional backgrounds, through a strong commitment to excellent teaching and academic quality. Excellent ICT skills including the use of virtual learning environment will also be crucial.\u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Lecturer/Senior Lecturer - Link Tutor in Business \u0026 Management","url":"https://bathspa.pinpointhq.com/en/postings/70cf5799-dcc1-482b-bf7c-282f36c114f6","path":"/en/postings/70cf5799-dcc1-482b-bf7c-282f36c114f6","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"209503","requisition_id":"232/23/24","department":{"id":"19085","name":"Business School"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"191379","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eProvisional Interview Dates - 31st July \u0026amp; 2nd August\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-14T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eThis is an exciting opportunity to join Bath Business School as a Teaching Fellow in Academic Partnership Support, helping to maintain and monitor our high academic standards for programmes delivered by our educational partners.\u0026nbsp; \u003cbr\u003e\u003cbr\u003eYou will provide academic support through moderation, and other associated academic support, for these business and management programmes. \u003cbr\u003e\u003cbr\u003eThese programmes are delivered away from Bath, across the UK and abroad, to over 15,000 students. \u0026nbsp;\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eWorking with colleagues from both Bath Business School but also with colleagues at the educational partnerships, you will maintain and monitor our high academic standards to ensure they are aligned to our assessment and marking policy.\u0026nbsp; \u003cbr\u003e\u003cbr\u003eThis will include ensuring the correct interpretation of our module material, assessment briefs and marking criteria as well as ensuring partner moderation is robust.\u0026nbsp; You will be involved in the whole assessment cycle through attendance at Subject Board and support for eVision navigation at these Boards.\u0026nbsp; \u003cbr\u003e\u003cbr\u003eYou will be based in the UK and be able to travel to and from Bath, although much of the work can be carried out remotely. \u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have relevant subject qualifications in business and management, along will university-level teaching experience, adept in diverse teaching methods and assessment practices in business and management programmes.\u003cbr\u003e\u003cbr\u003e\u0026nbsp;Excellent communication skills are essential for engaging with external partners and stakeholders, along with strong organisational, administrative, and IT skills. \u003cbr\u003e\u003cbr\u003eIn addition, you will work well in a small team and be capable of managing your time effectively with limited supervision and have experience working in virtual learning environments (VLE).\u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Academic Partnership Support (Teaching Fellow)","url":"https://bathspa.pinpointhq.com/en/postings/62cc6552-0292-42f2-bd71-4f7a19f9626e","path":"/en/postings/62cc6552-0292-42f2-bd71-4f7a19f9626e","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"209809","requisition_id":"232/23/24","department":{"id":"19085","name":"Business School"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"191396","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac3S - £42,978 - £45,585 per annum\u003cbr\u003e\u003cbr\u003e(There are 2 full time fixed term contracts, starting in September 2024)\u003cbr\u003e\u003cbr\u003e\u003c/strong\u003e\u003cstrong\u003e\u003cem\u003eWe reserve the right to close this vacancy early if we receive sufficient applications.\u0026nbsp;\u003cbr\u003eTherefore, if you are interested, please submit your application early.\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £45,585 / year","compensation_minimum":42978.0,"compensation_maximum":45585.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-17T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking 2 maternity-cover Lecturers in Psychology to join our dedicated and committed team at Bath Spa University.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e(There are 2 full time fixed term contracts, starting in September 2024)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will help design and deliver teaching content across a range of modules at Levels 4 to 6 in Psychology Programmes, as well as contributing to curriculum planning and development, and engaging in research or scholarly activity in Psychology.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will have the opportunity to develop new courses and help guide the focus of teaching and research in Psychology at Bath Spa University.\u003cbr\u003e\u003cbr\u003eYou will also be engaging in relevant research and scholarly activity in support of the university’s research strategy, to inform and enhance curriculum design and to improve student experience. In addition, you will be supervising or mentoring colleagues with less experience and advising them on personal development.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking an enthusiastic individual who will be able to teach Psychology at all undergraduate levels, who has a BPS-accredited degree in Psychology and experience teaching or researching psychology.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will be keen to contribute to activities such as involvement with open days, public events and building appropriate links with business and the community, as well as being involved in moderation and other quality assurance processes.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will have excellent networking and communication skills, flexible and adaptable to change and be a committed team player.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Lecturer in Psychology (Maternity Cover)","url":"https://bathspa.pinpointhq.com/en/postings/887b59c1-acd9-4196-8a04-5353219ff9cb","path":"/en/postings/887b59c1-acd9-4196-8a04-5353219ff9cb","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"209826","requisition_id":"290/23/24 \u0026 294/23/24","department":{"id":"25480","name":"School of Sciences"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"192178","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a permanent part-time role, 3 days per week: Wednesday, Thursday \u0026amp; Friday.\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 4 - £15,082 -£16,308 per annum, pro rata. £25,138-£27,181.\u003cbr\u003e\u003cbr\u003eInterview Date - Tuesday 30th July 2024\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003eWe reserve the right to close this vacancy early if we receive sufficient applications. \u003cbr\u003eTherefore, if you are interested, please submit your application early.\u003cbr\u003e\u003cbr\u003e\u003c/em\u003e\u003c/strong\u003e\u003cstrong\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£25,138 - £27,181 / year","compensation_minimum":25138.0,"compensation_maximum":27181.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-18T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking an enthusiastic Chancelry Administrator/Receptionist to join our busy department at Bath Spa University.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e(This is a permanent part-time role, 3 days per week: Wed, Thurs \u0026amp; Fri)\u0026nbsp;\u003c/div\u003e","employment_type":"part_time","employment_type_text":"Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe Vice-Chancellor’s office is a busy department, and this vacancy is a key role which is interesting, diverse and gives the opportunity of working with colleagues in a variety of departments and schools across the University as well as students and visitors to the institution.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role will require a self-motivated, enthusiastic and customer focussed individual who will deliver a range of administrative services to support existing systems and processes for the Chancelry Department and the wider university.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will jointly take responsibility for the University’s Main House reception area at our Newton Park campus under the direction of the Senior Chancelry Administrator and will be part of a reception team providing excellent customer service to our students, staff and visitors.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be friendly, personable and efficient and will pay close attention to detail. You will maintain effective working relationships, be self-motivated, possess enthusiasm and determination, and will be an effective team player who is always willing to support other colleagues.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will also be flexible, and an accurate and efficient administrator with good verbal and written communication skills, as well as being numerate and literate and will be able to easily move between different kinds of data with ease.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn addition, you will be effective in managing multiple work streams and deadlines in parallel and will work well under pressure.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Part Time Chancerly Administrator / Receptionist ","url":"https://bathspa.pinpointhq.com/en/postings/0e1dff0f-5f9c-41ea-a9c7-ac56e02c01b5","path":"/en/postings/0e1dff0f-5f9c-41ea-a9c7-ac56e02c01b5","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"210592","requisition_id":"332/23/24","department":{"id":"25472","name":"Chancelry"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"192280","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 5 - £27,979 - £31,396 per annum\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003cstrong\u003e\u003cem\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u003cem\u003e\u003cbr\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u003c/em\u003e\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£27,979 - £31,396 / year","compensation_minimum":27979.0,"compensation_maximum":31396.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-07-11T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eJoin our dynamic Finance team at Bath Spa University, Newton Park as a Student Fees Officer, where you'll play a pivotal role in managing student and external customer invoicing, account, and debt management for the University.\u003cbr\u003e\u003cbr\u003eThis essential role supports the University's operational reputation and ensures financial procedures are meticulously followed and upheld.\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs a Student Fees Officer, your main responsibilities will include ensuring all invoicing is accurate, complete, and raised according to agreed timetables and contract terms.\u003cbr\u003e\u003cbr\u003eYou will implement credit control processes to minimise debt, manage nonpayment actions, and prepare debt reporting. Providing support for complex tuition fee queries and collaborating with various departments to maintain high service levels is essential.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will assist with month-end activities, provide debtor reports, and support internal and external audits. Additionally, you will contribute to process reviews, manage system testing, and maintain awareness of policy changes affecting financial arrangements.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eTo be successful as a Student Fees Officer, you will need a good standard of education, including GCSE Maths and English (grade C or above) or NVQ2 equivalent. Experience in a financial operations environment with knowledge of account management and credit control is essential, along with proficiency in using Google Chrome, Word, and Excel. \u003cbr\u003e\u003cbr\u003eDesirably, you will be working towards or have completed an AAT qualification and have experience with accounting and bespoke finance systems. Experience in a large, complex organisation or equivalent, familiarity with debt management and statistical reporting to senior management, and experience with online County Court claims are also advantageous.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cbr\u003eYou must demonstrate a proactive customer service approach, strong negotiation and problem-solving skills, and excellent communication and interpersonal abilities. A solid understanding of basic accounting principles is required, and knowledge of the Higher Education environment is desirable. \u003cbr\u003e\u003cbr\u003ePersonal qualities needed include the ability to prioritise and manage your workload effectively, meet deadlines within agreed timetables, and continuously improve systems and processes.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Student Fees Officer","url":"https://bathspa.pinpointhq.com/en/postings/38e6d1ba-eb10-4ad2-9c14-45d6ab0d7d1e","path":"/en/postings/38e6d1ba-eb10-4ad2-9c14-45d6ab0d7d1e","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"210687","requisition_id":"334/23/24","department":{"id":"25475","name":"Finance"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}}]}
-  recorded_at: Thu, 27 Jun 2024 13:37:18 GMT
+        {"data":[{"id":"194729","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eInterview Dates - Monday 16th \u0026amp; Tuesday 17th September 2024 \u003cbr\u003e\u003cbr\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003c/strong\u003e\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003e\u003cstrong\u003ea.carr2@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-26T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking an experienced Early Years, primary and/or secondary age phase practitioner to take on the role of teacher and tutor for the academic assignments of BSU’s highly regarded SCITT PGCE programme.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eTeaching takes place both in-person at our SCITTs across England and online, with much of the course delivered virtually.\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University’s School of Education provides the SCITT PGCE award to a growing number of SCITT providers, working with 13 partners from September 2024.\u0026nbsp; Whilst the SCITT provides the training that leads to a recommendation for QTS, this role relates to Bath Spa University’s provision of the academic award of PGCE. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn order to support trainees in understanding the value of critical awareness of professional practice at Masters level, through the completion of academic assignments, the post holder will deliver: SCITT assignment launches, seminars to groups of trainees, individual tutorials, online support and assignment assessment. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe work of the SCITT PGCE programme is delivered at a range of sites across England.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have QTS, a first degree, a higher degree (or working towards a higher degree) and will be confident in teaching at Masters level and working with trainee teachers.\u0026nbsp; Experience of working in a school or other educational institution is essential.\u0026nbsp; Experience in the Early Years, primary and/or secondary age phase is essential, but you will also have knowledge and understanding of learning pedagogy and current thinking in wider educational issues. \u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent communication skills, a collaborative and enthusiastic approach to teacher education and be a committed team player.\u0026nbsp; You will be a confident communicator and user of IT, particularly online learning environments.\u0026nbsp; You must be a flexible thinker and be willing to engage in the development of this area of teacher education.\u003cbr\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003ea.carr2@bathspa.ac.uk\u003c/a\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow for School-Centred Initial Teacher Training (SCITT) PGCE Programme","url":"https://bathspa.pinpointhq.com/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","path":"/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"213031","requisition_id":"282/23/24","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"196971","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 7 - £37,099 - £41,732 per annum\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eInterview Date - W/C 12th August\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-04T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eThis is an exciting opportunity to join us as Strategic Projects \u0026amp; Change Manager at Bath Spa University. You will be involved in a wide range of strategic activities and will play a key role in managing and facilitating change projects, new ways of working, and process improvements.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs Strategic Projects \u0026amp; Change Manager you will manage project initiation phases, oversee large-scale programs, and ensure effective end-to-end project management. \u003cbr\u003e\u003cbr\u003eYou will work closely with senior leadership, project sponsors, and teams to meet project requirements, timelines, and outputs, while maintaining robust communication channels. \u003cbr\u003e\u003cbr\u003eYour role will involve coordinating project activities, supporting senior oversight groups, tracking project metrics, and developing best practice project management collateral. \u003cbr\u003e\u003cbr\u003eAdditionally, you will facilitate forums for cross-university collaboration, build strong networks across academic and professional services teams, and contribute to staff development and your own professional growth.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent stakeholder management skills with a demonstrable ability to communicate effectively with a diverse audience will be key. \u003cbr\u003e\u003cbr\u003eYou will have a structured approach to producing accurate project documentation and reporting, be self-motivated, and experienced at working at a strategic level across a varied workload.\u003cbr\u003e\u003cbr\u003eIn addition, you will be flexible, calm under pressure and will have excellent organisational and prioritisation skills\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Strategic Projects \u0026 Change Manager","url":"https://bathspa.pinpointhq.com/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","path":"/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"215223","requisition_id":"348/23/24","department":{"id":"36037","name":"Strategic Projects and Change Unit"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"197279","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eFull Time Fixed Term Contract initially for 12 months, although can be shortened or lengthened based on the maternity leave\u003cbr\u003e\u003cbr\u003eInterview Date - 14th August 2024\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking to recruit Teaching Fellows in Psychology to join our dedicated and committed team in Psychology.\u003cbr\u003e\u003cbr\u003e(Please note that the role is initially for 12 months, although can be shortened or lengthened based on the maternity leave)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will be the key support to undergraduate teaching across our programmes within Psychology. You will design and deliver teaching content across a range of modules at Levels 4 to 6 in Psychology Programmes, with a particular focus on Forensic Psychology, as well as contributing to curriculum planning and development, and engaging in research or scholarly activity in Psychology.\u003cbr\u003e\u003cbr\u003eYou will undertake teaching within Psychology in the form of lectures, practical sessions, seminars, discussions groups and tutorials as appropriate, whilst supporting undergraduate students individually and online.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn addition, you will help mark assessments associated with the teaching and will attend assessment and examination meetings as required.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking a flexible and positive individual who will be able to teach a broad range of Psychology at all undergraduate levels, with a particular focus on Forensic Psychology (though all areas of expertise are welcome) and have a BPS-Accredited undergraduate degree.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will have experience of teaching all aspects of general Psychology, as well as prior experience of different teaching methods and/or experience of university level teaching. As an excellent communicator, you will work successfully as part of a small team, whilst showing the ability to manage your own time with limited supervision.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role is available on a job-share basis that would enable you to complete postgraduate studies (e.g., a PhD) alongside the role.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor informal enquiries about the role, please contact Prof Peter Hills; \u003c/strong\u003e\u003ca href=\"mailto:p.hills@bathspa.ac.uk\"\u003e\u003cstrong\u003ep.hills@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow in Psychology (Maternity Cover)","url":"https://bathspa.pinpointhq.com/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","path":"/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"215498","requisition_id":"344/23/24","department":{"id":"25480","name":"School of Sciences"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198167","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a part time role, 28 hours per week.\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 6 - £24,457 - £27,261 per annum, pro rata £32,332-£36,024\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eSome evening and weekend working during term time will be required.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£24,457 - £27,261 per annum, pro rata £32,332-£36,024 ","compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking an dedicated Technical Demonstrator (moving image)\u003cstrong\u003e \u003c/strong\u003eto be responsible for the delivery of specialist technical skills demonstrations to either groups of students or one-to-one support to individuals here at Bath Spa University\u003cbr\u003e(This is a part time role, 28 hours per week)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"part_time","employment_type_text":"Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role of a Technical Demonstrator combines technical knowledge and innovative thinking with the design and delivery of hardware and software demonstrations to students. Within the role you will be responsible for ensuring the maintenance of specialist equipment is carried out within own area of work and that health and safety standards are complied with. This role will be based around the delivery of training and demonstration of moving image capture, motion graphics generation, editing and gallery presentation. It will be located at the Locksbrook Rd campus mainly working with students enrolled on courses within the Schools of Art, Film and Media and the School of Design.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eAs Technical Demonstrator you will demonstrate complex technical techniques to students from various programs, support individual and group student work, and develop and run workshops on the use of our facilities. You will be responsible for preparing resources and equipment, supervising students' project work, and ensuring health and safety compliance within the workspace. Additionally, you will conduct risk assessments, maintain equipment, and stay updated with new technologies and contemporary practices in your field. You may also advise on future resource requirements and supervise a small team of technical staff.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be a qualified Workshop and Laboratory Technician with an NVQ4, NEBSS, or degree in a relevant practical subject, or significant professional experience in a specialist area. You will have experience in demonstration or training, supervisory skills, and expertise in video capture, motion graphics, animation, and gallery presentation of moving images.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou should demonstrate a proactive approach to maintenance, development, and safety, possess excellent interpersonal, written, and oral communication skills, and have strong ICT capabilities.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe role requires the ability to plan and organise work, manage resources, liaise with staff, departments, and external agencies, use initiative and problem-solving skills, make decisions, and work under pressure to tight deadlines. Flexibility, adaptability, and a positive approach to change are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Technical Demonstrator (Moving Image)","url":"https://bathspa.pinpointhq.com/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","path":"/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"216378","requisition_id":"347/23/24","department":{"id":"30746","name":"Technical Services"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"198471","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the Games Development and Creative Computing (Games) courses at Bath Spa University.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of games design and development.\u0026nbsp;\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institution in games development or similar Creative Computing subjects. We expect that as a games and creative technology specialist, you will be actively engaged in related practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will ideally have additional industry and/or teaching experience using modern game engines such Unity3D and Unreal, and some knowledge of others. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience in a game production role is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer – Games Development","url":"https://bathspa.pinpointhq.com/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","path":"/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216674","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198483","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the BSc (HONS) Computing course at Bath Spa University. \u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of Computing.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institute in Computing subjects. We expect that as a Computing specialist, you will be actively engaged in computing practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have industry and/or teaching experience within one or more of the following areas: OO software development using C++, software engineering, and business analysis. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience developing creative and entertainment software is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer - Computing","url":"https://bathspa.pinpointhq.com/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","path":"/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216686","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198822","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eWe encourage applications from disabled people and can provide reasonable adjustments, so please let us know if there is anything we can do to make applying for this role more accessible for you. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eSalary: Grade 5 - £27,979 to £31,396 (per annum), £5,595.80 to £6,279.20 (pro-rata)\u003cbr\u003e\u003cbr\u003eThis is a 0.2 FTE part-time, one year fixed-term role.\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£27,979 - £31,396 / year","compensation_minimum":27979.0,"compensation_maximum":31396.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently\u003cstrong\u003e \u003c/strong\u003eseeking to appoint a Research Assistant to support the creation and development of a disability hub which aims to bring together and disseminate We Are The People research to the South West. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe Are The People (WATP) is a small research team of disabled academics and non-disabled allies engaged in disability research and disability activism. We've been awarded a five-year, £1million grant from the \u003ca href=\"https://wellcome.org/\"\u003e\u003cstrong\u003eWellcome Trust\u003c/strong\u003e\u003c/a\u003e to explore issues which affect disabled people in South West England.\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_part_time","employment_type_text":"Fixed Term - Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role involves developing an understanding of ongoing research by Disabled People’s Organisations (DPOs), creating a disability training programme led by disabled individuals, and organizing events to showcase findings. You will ensure the accessible dissemination of research results, investigate collaborative opportunities with DPOs, and build relationships with community contacts for future funding.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eKey responsibilities include providing guidance to community partners, contributing to meetings, adhering to Health and Safety guidelines, and developing research methods within the programme framework.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be passionate about disability equality and hold a good first degree in a relevant discipline such as Disability Studies, Psychology, Social Science, Arts, etc. You will also have demonstrable experience of working in a co-productive way with project partners, contributing to a community, charity or research environment.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will also show a demonstrable understanding of the sensitivities of working with underrepresented groups, and to respond to potential barriers in a compassionate way. In addition, you will be an excellent problem solver, flexible, adaptable and a committed team player. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact the team at: \u003ca href=\"mailto:WeAreThePeople@bathspa.ac.uk\"\u003eWeAreThePeople@bathspa.ac.uk\u003c/a\u003e \u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Research Assistant - We Are The People project","url":"https://bathspa.pinpointhq.com/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","path":"/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217032","requisition_id":"360_23_24  ","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199360","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis role is a one year fixed-term contact.\u003cbr\u003e\u003cbr\u003eSalary: Grade 8s, £42,978 to £44,263\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £44,263 / year","compensation_minimum":42978.0,"compensation_maximum":44263.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-11T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University is seeking a dynamic and innovative Head of Recruitment to lead and deliver cutting-edge resourcing solutions.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role focuses on developing sustainable staff recruitment strategies, optimizing our employer value proposition (EVP), and enhancing our recruitment branding across all platforms. (This is a 1 year Fixed Term Contract)\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will oversee a smooth and efficient recruitment process, enhancing both the candidate and hiring manager experience and will lead the recruitment team, providing expert guidance and support. Collaborating with senior managers, you will understand strategic recruitment needs and determine the best resourcing strategies. Proactive sourcing of hard-to-fill or senior roles through headhunting, microsites, and video content will be essential.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eSetting and reviewing key performance indicators (KPIs) will be a critical part of the role, ensuring effective recruitment processes and annual reporting on trends. You will embed our EVP through recruitment marketing techniques aligned with the University's values and culture and will build BSU’s presence on social media to increase engagement. Implementing initiatives to improve workforce diversity and ensuring recruitment efforts align with the University’s Equality, Diversity, and Inclusion (ED\u0026amp;I) Strategy is vital. Inclusive recruitment practices must be maintained throughout the candidate journey, and you will influence line managers to prioritise talent diversity.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eEstablishing and managing a talent pool process for future vacancies will be part of your remit, as well as building external networks to stay updated on recruitment trends and advising the University accordingly.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have proven expertise in employee resourcing strategies and recruitment processes, strong leadership and team management skills, and experience in developing and implementing EVP.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eProficiency in utilising social media for recruitment, a commitment to diversity and inclusion in the workplace, and excellent communication and relationship-building skills are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Head of Recruitment","url":"https://bathspa.pinpointhq.com/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","path":"/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217566","requisition_id":"254-23-24","department":{"id":"19087","name":"HR"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199810","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eTemporary, fixed term Semester/Trimester one and two 2024 -2025. Part Time Hours to be agreed.\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eGeneral teaching commences week beginning 30th September 2024 but module development will before these date. Our 2024/5 term dates can be found at https://www.bathspa.ac.uk/about-us/term-dates/\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are looking for talented Associate Lecturers in Law to join our collegial team, contributing to teaching and development of law modules on a part time basis at various times through the 2024/2025 academic year.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Associate Lecturer posts require lecturing, taking seminar groups, assessment and working as part of a team of tutors.\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAt Bath Spa University we work with one clear vision: to be a leading university in creativity, culture and enterprise. And we place collaboration at the heart of everything we do. With ever growing student numbers, we make sure our people are engaged and empowered by blending digital technologies, international perspectives, work-oriented connections and inspirational teaching. Together we’re on a journey to transform our students’ lives. And it starts with people like you.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eAbout Bath Business School\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eBath Business School is set within a beautiful countryside location, close to the world heritage city of Bath. Our staff and students are ethically aware, socially engaged and globally connected through our links to research, and professional and creative industry networks.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eOur Law Degree\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eOur new LLB Law degree has been designed to be unique and incorporates a range of business skills and optional modules whilst encompassing the foundations of legal knowledge found in SQE 1 and many elements of SQE 2.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Bath Spa LLB is at the cutting edge of legal education. Our LLB offers a range of authentic assessments, the offer of multiple placement opportunities including a placement year, as well as the opportunity of undertaking the Law Clinic module for final year students.\u0026nbsp; Our Law Clinic is a result of an impressive joint venture between Bath Spa University, Stone King LLP and the Citizens Advice Bureau BANES.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe believe in giving our students a high-quality educational experience, exceptional opportunities to become highly employable as well as unrivalled pastoral care.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor further information contact Steven Goulton, Law Course Director, Bath Business School, \u003c/strong\u003e\u003ca href=\"mailto:s.goulton@bathspa.ac.uk\"\u003e\u003cstrong\u003es.goulton@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","key_responsibilities_header":"About Us.","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eIdeally you will have expertise in one or more of the following areas (please see below for further information on Associate Lecturer role specifics):\u003c/div\u003e\u003cul\u003e\u003cli\u003e\u003c!--block--\u003eTort Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmployment Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eBusiness Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eDissertation supervision\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEquity and trusts\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eProperty Law\u0026nbsp;\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmerging technologies – AI, cyberlaw etc\u003c/li\u003e\u003c/ul\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer in Law","url":"https://bathspa.pinpointhq.com/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","path":"/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218013","requisition_id":"","department":{"id":"19085","name":"Business School"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199873","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - 11th \u0026amp; 12th September 2024\u003cbr\u003e\u003cbr\u003ePlease email Clara Giaminardi \u003c/strong\u003e\u003ca href=\"mailto:c.giaminardi@bathspa.ac.uk\"\u003e\u003cstrong\u003ec.giaminardi@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e directly for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eOur BA (Hons) Fashion Photography course is looking for associate lecturers with in-depth knowledge and/or industry experience in the areas of fashion photography, fashion styling and fashion communication to deliver teaching on our level 4 and level 5 modules.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs an associate lecturer on BA (Hons) Fasion Photography, your primary responsibility will be delivering engaging and high quality teaching in the appropriate subject area. This includes developing and undertaking in-person lectures, practical workshops, seminars and tutorials to support our level 4 and level 5 students in the development of their work.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eIn the role, you will also be marking and assessing module work, providing constructive feedback and attending assessment meetings where required to ensure fair and consistent grading. You will also be expected to work closely with module staff and support on some administrative tasks, ensuring the smooth running of the module. This includes engaging with existing virtual learning environments to ensure cohesive dissemination of module materials and student communication across the course.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eThe role requires an in-depth subject knowledge and/or industry expertise in the areas of fashion photography, fashion styling and/or fashion communication. You will have excellent communication and interpersonal skills and will be able to translate key skills and concepts into appropriate language and tasks for level 4 and level 5 students. A solid understanding of contemporary trends and industry practices is essential to ensure high quality of teaching for students going into future industry.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003ePrior experience teaching undergraduate students in these areas is desirable. You will have excellent organisational and time management skills, and be able to work successfully as part of a small team. Alongside solid IT skills, expertise in industry specific digital tools such as the Adobe Creative Suite is beneficial.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer, BA (Hons) Fashion Photography","url":"https://bathspa.pinpointhq.com/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","path":"/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218077","requisition_id":"","department":{"id":"36272","name":"School of Art, Film \u0026 Media"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"200623","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a Fixed Term Contract until November 2024.\u003cbr\u003e\u003cbr\u003eSalary: Grade 2, £23,152\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u003c/strong\u003e\u003cbr\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£23,152 / year","compensation_minimum":23152.0,"compensation_maximum":23152.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-05T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eExciting opportunity for a reliable and dedicated individual to join our elite Facilities and Services team in helping maintain a clean and safe environment on our Sion Hill Campus. (This is a Fixed Term Contract until November 2024)\u003cbr\u003e\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eOur team prides ourselves on our positive ‘can do’ approach towards supporting our students, staff and visitors.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eAs a valued member of our vibrant team, you'll be the unsung hero behind the scenes, transforming every corner of our campus into a sparkling haven of knowledge and innovation at the same time as providing excellent customer service.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eEmbrace the excitement of a dynamic environment where no two days are alike.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eDue to the University’s locations, having your own transport is recommended, however, there is the option of public transport (this is limited during the summer months).\u003cbr\u003e\u0026nbsp;\u003cbr\u003eCleaning experience is beneficial but what we’re looking for most is reliability, attention to detail and a willingness to learn.\u003cbr\u003e\u0026nbsp;\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Full Time Cleaner (Fixed Term Contract)","url":"https://bathspa.pinpointhq.com/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","path":"/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218783","requisition_id":"","department":{"id":"25473","name":"Estates"},"division":null,"structure_custom_group_one":null},"location":{"id":"14960","city":"Bath","name":"Bath - Sion Hill Campus","province":"Bath"}}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:00 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.bathspa.ac.uk/"]}],"limit":1}'
@@ -167,9 +167,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Thu, 27 Jun 2024 13:37:18 GMT
+      - Tue, 30 Jul 2024 16:28:01 GMT
       Etag:
-      - W/"1719495438784"
+      - W/"1722356881527"
       Server:
       - openresty
       X-Cb-Engine:
@@ -181,11 +181,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '5'
+      - '4'
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '15'
+      - '14'
       Content-Length:
       - '615'
       Connection:
@@ -196,6 +196,6 @@ http_interactions:
         Spa University","identifier":{"permalink":"bath-spa-university-2","image_id":"v1488530438/cej4b9ng1amolmbwoqp0.png","uuid":"f221c78f-54eb-1f68-967d-87d6046d43e5","entity_def_id":"organization","value":"Bath
         Spa University"},"linkedin":{"value":"https://www.linkedin.com/company/bath-spa-university"},"short_description":"Bath
         Spa offers undergraduate and postgraduate study and research opportunities
-        with a focus on creativity, culture and enterprise.","rank_org":356637,"website_url":"https://www.bathspa.ac.uk/"}}]}'
-  recorded_at: Thu, 27 Jun 2024 13:37:18 GMT
+        with a focus on creativity, culture and enterprise.","rank_org":452146,"website_url":"https://www.bathspa.ac.uk/"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:01 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_recruitee.yml b/spec/fixtures/cassettes/create_company_recruitee.yml
index 19671517..2004f731 100644
--- a/spec/fixtures/cassettes/create_company_recruitee.yml
+++ b/spec/fixtures/cassettes/create_company_recruitee.yml
@@ -25,7 +25,7 @@ http_interactions:
       Content-Type:
       - text/html; charset=utf-8
       Date:
-      - Thu, 27 Jun 2024 13:37:19 GMT
+      - Tue, 30 Jul 2024 16:28:01 GMT
       Referrer-Policy:
       - strict-origin-when-cross-origin
       Server:
@@ -43,7 +43,7 @@ http_interactions:
       X-Permitted-Cross-Domain-Policies:
       - none
       X-Request-Id:
-      - F9zf_ege9mnjCgICGjfC
+      - F-cKdV3bqhEzy2sBLoRB
       Via:
       - 1.1 google
       Alt-Svc:
@@ -53,8 +53,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        <!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>




      <meta content="Careers homepage" name="description"/>

      <meta content="Careers homepage" property="og:description"/>
      <meta content="https://radishlab.recruitee.com/" property="og:url"/>
      <meta content="Radish Lab" property="og:site_name"/>

      <meta content="website" property="og:type"/>

      <meta content="https://careers.recruiteecdn.com/image/upload/q_auto,w_1920,c_limit/production/images/AQJm/eTpqtQ6sZ9sc.jpeg" property="og:image"/>
      <meta content="800" property="og:image:width"/>
      <meta content="418" property="og:image:height"/>


<style data-styled="true" data-styled-version="5.1.1">.eFVUhY{font-size:32px;line-height:1.2em;color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:600;font-style:normal;text-transform:none;text-wrap:balance;margin-top:0px;margin-bottom:0px;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;word-break:normal;overflow-wrap:break-word;margin-top:28px;margin-bottom:28px;}/*!sc*/
@media only screen and (min-width:768px){.eFVUhY{font-size:48px;}}/*!sc*/
data-styled.g4[id="sc-1npqnwg-3"]{content:"eFVUhY,"}/*!sc*/
.fXpJdS{font-size:24px;line-height:1.2em;color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:600;font-style:normal;text-transform:none;text-wrap:balance;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;word-break:normal;overflow-wrap:break-word;margin-top:0px;margin-bottom:0px;margin-top:28px;margin-bottom:28px;}/*!sc*/
@media only screen and (min-width:768px){.fXpJdS{font-size:32px;}}/*!sc*/
data-styled.g6[id="sc-1npqnwg-5"]{content:"fXpJdS,"}/*!sc*/
.iPueVD{font-size:16px;line-height:1.6em;color:#000000;font-weight:400;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;margin-top:0px;margin-bottom:0px;margin-top:20px;margin-bottom:20px;}/*!sc*/
@media only screen and (min-width:768px){.iPueVD{font-size:20px;}}/*!sc*/
data-styled.g11[id="sc-1npqnwg-10"]{content:"iPueVD,"}/*!sc*/
.eDCgIN{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;}/*!sc*/
.eDCgIN::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.eDCgIN{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.eDCgIN{line-height:1.6em;}}/*!sc*/
.jmbcoz{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;font-size:16px;line-height:1.5em;}/*!sc*/
.jmbcoz::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{line-height:1.6em;}}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{font-size:16px;}}/*!sc*/
.xZUGZ{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;border:1px solid #000000;background-color:#000000;color:#ffffff;}/*!sc*/
.xZUGZ::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.xZUGZ{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.xZUGZ{line-height:1.6em;}}/*!sc*/
.xZUGZ:hover{border:1px solid #000;background-color:#000;color:#ffffff;}/*!sc*/
data-styled.g13[id="sc-s03za1-0"]{content:"eDCgIN,jmbcoz,xZUGZ,"}/*!sc*/
.bIScAX{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-self:center;-ms-flex-item-align:center;align-self:center;color:currentColor;pointer-events:none;}/*!sc*/
data-styled.g21[id="sc-1rd450u-0"]{content:"bIScAX,"}/*!sc*/
.cPMqMQ{font-size:inherit;color:#000000;}/*!sc*/
data-styled.g43[id="sc-5egf6r-0"]{content:"cPMqMQ,"}/*!sc*/
.cKZGOF{line-height:1.5em;}/*!sc*/
.cKZGOF .sc-1tu8yb8-0{display:none;}/*!sc*/
.cKZGOF > :first-child{margin-top:0 !important;}/*!sc*/
.cKZGOF > :last-child{margin-bottom:0 !important;}/*!sc*/
data-styled.g45[id="sc-1tu8yb8-1"]{content:"cKZGOF,"}/*!sc*/
.gXycJU{width:16px;min-width:16px;}/*!sc*/
data-styled.g71[id="sc-1jf9qcy-0"]{content:"gXycJU,"}/*!sc*/
.beiMHd{display:none;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding:32px 0px;font-size:18px;line-height:normal;border-top:1px solid rgba(0,0,0,0.25);background-color:#fff;}/*!sc*/
data-styled.g89[id="sc-1ktojtq-0"]{content:"beiMHd,"}/*!sc*/
.eovEqQ{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
data-styled.g90[id="sc-1ktojtq-1"]{content:"eovEqQ,"}/*!sc*/
.gJxpwG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;min-height:66vh;}/*!sc*/
.gQRcOO{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;min-height:33vh;}/*!sc*/
.kmsnUh{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;}/*!sc*/
data-styled.g91[id="sc-gfrfnr-0"]{content:"gJxpwG,gQRcOO,kmsnUh,"}/*!sc*/
.iVfIXi{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;background-repeat:no-repeat;background-position:center center;background-size:cover;z-index:1;}/*!sc*/
data-styled.g92[id="sc-gfrfnr-1"]{content:"iVfIXi,"}/*!sc*/
.deOrHQ{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;isolation:isolate;}/*!sc*/
data-styled.g93[id="sc-gfrfnr-2"]{content:"deOrHQ,"}/*!sc*/
@media only screen{.ixGbOy{display:block;}}/*!sc*/
@media only screen and (min-width:768px){.ixGbOy{display:block;}}/*!sc*/
data-styled.g94[id="sc-1oxti4r-0"]{content:"ixGbOy,"}/*!sc*/
.UZqcu{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;width:100%;height:100%;object-position:center center;object-fit:cover;z-index:0;}/*!sc*/
data-styled.g97[id="sc-itprxg-0"]{content:"UZqcu,"}/*!sc*/
.ebVyJP{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;position:relative;}/*!sc*/
data-styled.g101[id="sc-18h7are-0"]{content:"ebVyJP,"}/*!sc*/
.guycoN{width:100%;padding-top:48px;padding-bottom:48px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:992px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:1200px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:1600px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
.gZDsxt{width:100%;padding-top:20px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
.kdUgoN{width:100%;padding-top:32px;padding-bottom:32px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:992px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:1200px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:1600px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
.hacApq{width:100%;padding-top:32px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
.dLnXab{width:100%;padding-top:48px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
data-styled.g106[id="sc-1tu9fip-1"]{content:"guycoN,gZDsxt,kdUgoN,hacApq,dLnXab,"}/*!sc*/
.gJVWbp{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
.bSaXtg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;}/*!sc*/
data-styled.g107[id="sc-1tu9fip-2"]{content:"gJVWbp,bSaXtg,"}/*!sc*/
.jIYAZB{margin:0 auto;width:100%;max-width:calc(100% - 48px);}/*!sc*/
@media only screen and (min-width:768px){.jIYAZB{max-width:704px;}}/*!sc*/
@media only screen and (min-width:992px){.jIYAZB{max-width:920px;}}/*!sc*/
@media only screen and (min-width:1200px){.jIYAZB{max-width:1152px;}}/*!sc*/
data-styled.g109[id="sc-ji5wy4-0"]{content:"jIYAZB,"}/*!sc*/
.dbJNvX{margin:0 auto;width:100%;max-width:calc(100% - 48px);}/*!sc*/
@media only screen and (min-width:768px){.dbJNvX{max-width:704px;}}/*!sc*/
@media only screen and (min-width:992px){.dbJNvX{max-width:920px;}}/*!sc*/
@media only screen and (min-width:1200px){.dbJNvX{max-width:1152px;}}/*!sc*/
data-styled.g125[id="sc-1dj1hqi-0"]{content:"dbJNvX,"}/*!sc*/
.dDTKOA{--gap:0px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.bEnYHY{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.jEioAK{--gap:24px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.ebMZHP{--gap:16px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.iozrWS{--gap:16px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;}/*!sc*/
.hohQBp{--gap:0px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;}/*!sc*/
data-styled.g126[id="sc-1dj1hqi-1"]{content:"dDTKOA,bEnYHY,jEioAK,ebMZHP,iozrWS,hohQBp,"}/*!sc*/
.dvhjIe{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.dvhjIe{width:100%;}}/*!sc*/
.hPupHS{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.hPupHS{width:calc( 50% - var(--gap) + ((var(--gap) / var(--columns)) * 6) );}}/*!sc*/
.fXdQP{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.fXdQP{width:calc( 50% - var(--gap) + ((var(--gap) / var(--columns)) * 6) );}}/*!sc*/
.lbZeFW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:calc( 25% - var(--gap) + ((var(--gap) / var(--columns)) * 3) );}/*!sc*/
@media only screen and (min-width:768px){.lbZeFW{width:calc( 25% - var(--gap) + ((var(--gap) / var(--columns)) * 3) );}}/*!sc*/
data-styled.g127[id="sc-1dj1hqi-2"]{content:"dvhjIe,hPupHS,fXdQP,lbZeFW,"}/*!sc*/
.jLGbJs{-webkit-transition:background-color 0.14s ease-in-out,color 0.14s ease-in-out;transition:background-color 0.14s ease-in-out,color 0.14s ease-in-out;}/*!sc*/
data-styled.g128[id="sc-3k6t01-0"]{content:"jLGbJs,"}/*!sc*/
.kJLltb{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;max-width:calc(100% - 48px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-flex:1;-ms-flex:1;flex:1;}/*!sc*/
data-styled.g130[id="sc-1aabq8s-1"]{content:"kJLltb,"}/*!sc*/
.kcKagb{margin-left:14px;margin-right:-2px;}/*!sc*/
data-styled.g133[id="sc-1aabq8s-4"]{content:"kcKagb,"}/*!sc*/
.QEQag{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding-left:8px;padding-right:8px;-webkit-text-decoration:none;text-decoration:none;overflow:hidden;opacity:1;-webkit-transition:opacity 0.14s ease-in-out;transition:opacity 0.14s ease-in-out;height:80px;margin:-20px 0;color:#fff;color:inherit;}/*!sc*/
data-styled.g142[id="sc-pxbyo9-0"]{content:"QEQag,"}/*!sc*/
.klfKrz{display:block;width:auto;max-width:200px;max-height:55%;justify-self:start;margin-right:0;}/*!sc*/
@media only screen and (min-width:768px){.klfKrz{width:auto;}}/*!sc*/
data-styled.g143[id="sc-83wl6d-0"]{content:"klfKrz,"}/*!sc*/
.eNDDPg{white-space:nowrap;font-weight:600;font-size:16px;text-overflow:ellipsis;overflow:hidden;display:none;}/*!sc*/
@media only screen and (min-width:768px){.eNDDPg{overflow:initial;text-overflow:unset;font-size:22px;}}/*!sc*/
data-styled.g144[id="sc-83wl6d-1"]{content:"eNDDPg,"}/*!sc*/
.dPcHAE{display:inline-block;padding:8px 12px;font-size:16px;line-height:24px;text-align:center;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;margin:0 2px;color:#fff;font-weight:600;font-style:normal;text-transform:none;}/*!sc*/
.dPcHAE:hover,.dPcHAE:focus{background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g145[id="sc-ir8rf5-0"]{content:"dPcHAE,"}/*!sc*/
.hLPFpI{width:100%;border-radius:4px;overflow-x:hidden;overflow-y:auto;text-align:center;box-shadow:0 2px 8px rgba(0,0,0,0.12);padding:8px 4px;}/*!sc*/
body.is-keyboard-focused .hLPFpI [role='menuitem'][data-selected]{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
body.is-keyboard-focused .hLPFpI [role='menuitem']{-webkit-transition:undefined;transition:undefined;}/*!sc*/
@media only screen and (min-width:768px){.hLPFpI{width:auto;}}/*!sc*/
data-styled.g156[id="sc-1tu9xny-0"]{content:"hLPFpI,"}/*!sc*/
.kZTElj{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:58px;width:100%;text-align:center;padding:12px 16px;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;color:#000000;}/*!sc*/
.kZTElj[data-selected]{color:#000000;background-color:rgba(0,0,0,0.05);}/*!sc*/
data-styled.g157[id="sc-1tu9xny-1"]{content:"kZTElj,"}/*!sc*/
.iPvmIC{margin:1px 0;font-size:16px;line-height:22px;border-color:#fff;color:#fff;font-weight:600;font-style:normal;text-transform:none;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:40px;min-width:40px;margin:0px;}/*!sc*/
@media only screen and (min-width:768px){.iPvmIC{line-height:22px;}}/*!sc*/
.iPvmIC[data-selected],.iPvmIC:hover,.iPvmIC:focus{color:rgba(255,255,255,0.9);background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g158[id="sc-1tu9xny-2"]{content:"iPvmIC,"}/*!sc*/
.cAzrSG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:40px;min-width:40px;margin:0px;}/*!sc*/
data-styled.g159[id="sc-1tu9xny-3"]{content:"cAzrSG,"}/*!sc*/
.hlNgLl{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding:8px;margin:0 2px;text-align:center;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;width:40px;height:40px;color:#fff;}/*!sc*/
.hlNgLl:hover{background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g167[id="sc-7glywv-0"]{content:"hlNgLl,"}/*!sc*/
.hdTF{list-style:none;padding-left:0;margin-top:0;margin-bottom:0;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;row-gap:8px;-webkit-box-pack:end;-webkit-justify-content:flex-end;-ms-flex-pack:end;justify-content:flex-end;}/*!sc*/
data-styled.g168[id="sc-1xewqye-0"]{content:"hdTF,"}/*!sc*/
@media only screen and (min-width:768px){.iudIDi{position:relative;}}/*!sc*/
data-styled.g174[id="sc-1tx5im8-0"]{content:"iudIDi,"}/*!sc*/
.hBOHsL{position:absolute;width:calc(100% - 48px);margin-left:24px;margin-right:24px;top:calc( 100% - 10px );left:0;z-index:1;}/*!sc*/
@media only screen and (min-width:768px){.hBOHsL{top:calc(100% + 10px);right:0;left:auto;width:-webkit-max-content;width:-moz-max-content;width:max-content;min-width:312px;margin-left:0;margin-right:0;}}/*!sc*/
.hBOHsL div[role='menu']{overscroll-behavior:contain;max-height:calc( 100vh - px - 12px );max-height:calc( 100dvh - px - 12px );}/*!sc*/
data-styled.g175[id="sc-1tx5im8-1"]{content:"hBOHsL,"}/*!sc*/
.cghDST{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;max-width:calc(100% - 48px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-flex:1;-ms-flex:1;flex:1;}/*!sc*/
@media only screen and (min-width:768px){.cghDST{max-width:100%;-webkit-box-flex:unset;-webkit-flex-grow:unset;-ms-flex-positive:unset;flex-grow:unset;}}/*!sc*/
data-styled.g176[id="sc-1hkznj2-0"]{content:"cghDST,"}/*!sc*/
.guEbMs{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}/*!sc*/
data-styled.g177[id="sc-1hkznj2-1"]{content:"guEbMs,"}/*!sc*/
.dYPHZW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;width:100%;display:none;}/*!sc*/
@media only screen and (min-width:768px){.dYPHZW{width:100%;}}/*!sc*/
@media only screen and (min-width:992px){.dYPHZW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}}/*!sc*/
data-styled.g187[id="sc-it5itd-0"]{content:"dYPHZW,"}/*!sc*/
.ciZwhu{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media only screen and (min-width:768px){.ciZwhu{width:100%;}}/*!sc*/
@media only screen and (min-width:992px){.ciZwhu{display:none;}}/*!sc*/
data-styled.g188[id="sc-it5itd-1"]{content:"ciZwhu,"}/*!sc*/
.kllnfT{position:relative;}/*!sc*/
data-styled.g191[id="sc-z9o81a-0"]{content:"kllnfT,"}/*!sc*/
.fsBFXt{position:absolute;top:0;left:0;width:100%;z-index:2001;}/*!sc*/
data-styled.g192[id="sc-z9o81a-1"]{content:"fsBFXt,"}/*!sc*/
.hfKXfE{visibility:hidden;width:100%;pointer-events:none;}/*!sc*/
data-styled.g193[id="sc-lqj8ks-0"]{content:"hfKXfE,"}/*!sc*/
.bKUtEV{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;height:100%;width:100%;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;}/*!sc*/
.hYJywo{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;height:100%;width:100%;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
data-styled.g196[id="sc-pelm1o-0"]{content:"bKUtEV,hYJywo,"}/*!sc*/
.cOPlFo{width:100%;text-align:left;}/*!sc*/
.ipivQc{width:100%;text-align:center;}/*!sc*/
data-styled.g197[id="sc-pelm1o-1"]{content:"cOPlFo,ipivQc,"}/*!sc*/
.hmrXLz{width:100%;}/*!sc*/
data-styled.g198[id="sc-pelm1o-2"]{content:"hmrXLz,"}/*!sc*/
.iOQKaL{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
@media only screen and (min-width:768px){.iOQKaL{-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;}}/*!sc*/
.OebVS{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
@media only screen and (min-width:768px){.OebVS{-webkit-flex-direction:row-reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse;}}/*!sc*/
data-styled.g199[id="sc-bq9z91-0"]{content:"iOQKaL,OebVS,"}/*!sc*/
.eDtYEt{z-index:1;}/*!sc*/
data-styled.g233[id="sc-1l3pw7p-0"]{content:"eDtYEt,"}/*!sc*/
.homvAg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
data-styled.g355[id="sc-73r8cv-0"]{content:"homvAg,"}/*!sc*/
.ilRiFP{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;width:100%;background-color:#fff;min-height:inherit;}/*!sc*/
data-styled.g356[id="sc-73r8cv-1"]{content:"ilRiFP,"}/*!sc*/
.fDyLzp{position:relative;overflow:hidden;width:100%;}/*!sc*/
.fDyLzp::before{content:'';display:block;padding-bottom:100.00%;}/*!sc*/
data-styled.g368[id="sc-dkkku4-0"]{content:"fDyLzp,"}/*!sc*/
.dHdKMs{position:absolute;top:0;left:0;right:0;bottom:0;}/*!sc*/
data-styled.g369[id="sc-dkkku4-1"]{content:"dHdKMs,"}/*!sc*/
.cTyKMn{max-width:100%;width:100%;height:auto;}/*!sc*/
.ftWfoy{max-width:100%;width:100%;height:auto;object-fit:cover;height:100%;}/*!sc*/
data-styled.g372[id="sc-146moy0-0"]{content:"cTyKMn,ftWfoy,"}/*!sc*/
.lcroFG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;width:100%;height:auto;position:relative;}/*!sc*/
data-styled.g389[id="sc-11gkm9w-0"]{content:"lcroFG,"}/*!sc*/
.YAzbZ{width:100%;height:auto;}/*!sc*/
data-styled.g390[id="sc-11gkm9w-1"]{content:"YAzbZ,"}/*!sc*/
.bpnyeu{position:relative;width:100%;height:100%;display:block;}/*!sc*/
data-styled.g433[id="sc-fw9s8b-0"]{content:"bpnyeu,"}/*!sc*/
.bJoAoi{font-size:16px;line-height:1.6em;color:#000000;font-weight:400;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;min-width:100%;color:#000000;border-collapse:collapse;}/*!sc*/
@media only screen and (min-width:768px){.bJoAoi{font-size:20px;}}/*!sc*/
.bJoAoi thead tr,.bJoAoi tbody tr:not(:last-of-type){border-bottom:1px solid rgba(0,0,0,0.25);}/*!sc*/
.bJoAoi th{color:rgba(0,0,0,0.8);font-weight:inherit;}/*!sc*/
.bJoAoi th,.bJoAoi td{height:64px;text-align:left;padding:8px;}/*!sc*/
.bJoAoi th:first-of-type,.bJoAoi td:first-of-type{padding-left:0;}/*!sc*/
.bJoAoi th:last-of-type,.bJoAoi td:last-of-type{padding-right:0;}/*!sc*/
.bJoAoi td{height:80px;}/*!sc*/
data-styled.g471[id="sc-18rtkup-0"]{content:"bJoAoi,"}/*!sc*/
.hhapWv{max-width:100%;overflow-x:auto;padding:0 4px;}/*!sc*/
data-styled.g472[id="sc-18rtkup-1"]{content:"hhapWv,"}/*!sc*/
.bqJcqI{color:#000000;font-weight:400;font-style:normal;text-transform:none;-webkit-text-decoration:none;text-decoration:none;word-break:break-word;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;}/*!sc*/
.bqJcqI:hover{color:#000;}/*!sc*/
data-styled.g473[id="sc-18rtkup-2"]{content:"bqJcqI,"}/*!sc*/
.ffHrMJ{margin:0 -4px;}/*!sc*/
data-styled.g474[id="sc-1qe5ahw-0"]{content:"ffHrMJ,"}/*!sc*/
.brHqfD{font-size:16px;line-height:24px;}/*!sc*/
data-styled.g475[id="sc-465zle-0"]{content:"brHqfD,"}/*!sc*/
.fTGeMR{margin-top:20px;padding-bottom:20px;border-bottom:1px solid rgba(0,0,0,0.25);}/*!sc*/
data-styled.g476[id="sc-465zle-1"]{content:"fTGeMR,"}/*!sc*/
.bCpqiX{font-weight:500;color:#000000;-webkit-text-decoration:none;text-decoration:none;word-break:break-word;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;}/*!sc*/
.bCpqiX:hover{color:#000;}/*!sc*/
data-styled.g477[id="sc-465zle-2"]{content:"bCpqiX,"}/*!sc*/
.gkgGSG{position:relative;margin-top:8px;color:#000000;}/*!sc*/
data-styled.g478[id="sc-465zle-3"]{content:"gkgGSG,"}/*!sc*/
.jvvolj{width:20px;height:20px;display:inline-block;margin-right:8px;}/*!sc*/
.jvvolj > *{position:absolute;top:4px;left:0px;}/*!sc*/
data-styled.g479[id="sc-465zle-4"]{content:"jvvolj,"}/*!sc*/
.WxTrG{margin-top:12px;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;-webkit-align-items:end;-webkit-box-align:end;-ms-flex-align:end;align-items:end;gap:40px;}/*!sc*/
data-styled.g480[id="sc-465zle-5"]{content:"WxTrG,"}/*!sc*/
.exQcZ{display:none;}/*!sc*/
@media only screen and (min-width:768px){.exQcZ{display:block;}}/*!sc*/
data-styled.g481[id="sc-1dywz0m-0"]{content:"exQcZ,"}/*!sc*/
.gcbsVn{display:block;}/*!sc*/
@media only screen and (min-width:768px){.gcbsVn{display:none;}}/*!sc*/
data-styled.g482[id="sc-1dywz0m-1"]{content:"gcbsVn,"}/*!sc*/
.dWcJRW{display:block;}/*!sc*/
@media only screen and (min-width:768px){.dWcJRW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}}/*!sc*/
data-styled.g489[id="sc-1mxcttb-0"]{content:"dWcJRW,"}/*!sc*/
.dPfocN{width:100%;}/*!sc*/
data-styled.g492[id="sc-4j8eof-0"]{content:"dPfocN,"}/*!sc*/
.jFfmvQ{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
data-styled.g493[id="sc-4j8eof-1"]{content:"jFfmvQ,"}/*!sc*/
.iOxTuT{opacity:1;}/*!sc*/
data-styled.g494[id="sc-4j8eof-2"]{content:"iOxTuT,"}/*!sc*/
.iZuBTr{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;text-align:left;}/*!sc*/
data-styled.g503[id="sc-1we8l0o-0"]{content:"iZuBTr,"}/*!sc*/
.kNKRnF{width:100%;-webkit-transition:width 0.1s linear,padding 0.1s linear;transition:width 0.1s linear,padding 0.1s linear;}/*!sc*/
@media only screen and (min-width:768px){.kNKRnF{width:100%;}}/*!sc*/
data-styled.g504[id="sc-1we8l0o-1"]{content:"kNKRnF,"}/*!sc*/
.gBDROR{position:absolute;top:0px;left:0px;border:0;-webkit-clip:rect(0 0 0 0);clip:rect(0 0 0 0);height:1px;width:1px;margin:-1px;padding:0;overflow:hidden;}/*!sc*/
.gBDROR:focus-within{background-color:#fff;z-index:1000;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:auto;height:auto;margin:0px;padding:6px;-webkit-clip:auto;clip:auto;}/*!sc*/
data-styled.g508[id="sc-q8cmux-0"]{content:"gBDROR,"}/*!sc*/
.kJsRIK{color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.kJsRIK:focus{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
data-styled.g509[id="sc-q8cmux-1"]{content:"kJsRIK,"}/*!sc*/
.jbcdEK{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
data-styled.g510[id="sc-ax9y9i-0"]{content:"jbcdEK,"}/*!sc*/
html{line-height:1.15;-webkit-text-size-adjust:100%;}/*!sc*/
body{margin:0;}/*!sc*/
main{display:block;}/*!sc*/
h1{font-size:2em;margin:0.67em 0;}/*!sc*/
hr{box-sizing:content-box;height:0;overflow:visible;}/*!sc*/
pre{font-family:monospace,monospace;font-size:1em;}/*!sc*/
a{background-color:transparent;}/*!sc*/
abbr[title]{border-bottom:none;-webkit-text-decoration:underline;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;}/*!sc*/
b,strong{font-weight:bolder;}/*!sc*/
code,kbd,samp{font-family:monospace,monospace;font-size:1em;}/*!sc*/
small{font-size:80%;}/*!sc*/
sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline;}/*!sc*/
sub{bottom:-0.25em;}/*!sc*/
sup{top:-0.5em;}/*!sc*/
img{border-style:none;}/*!sc*/
button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0;}/*!sc*/
button,input{overflow:visible;}/*!sc*/
button,select{text-transform:none;}/*!sc*/
button,[type='button'],[type='reset'],[type='submit']{-webkit-appearance:none;}/*!sc*/
button::-moz-focus-inner,[type='button']::-moz-focus-inner,[type='reset']::-moz-focus-inner,[type='submit']::-moz-focus-inner{border-style:none;padding:0;}/*!sc*/
fieldset{padding:0.35em 0.75em 0.625em;}/*!sc*/
legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal;}/*!sc*/
progress{vertical-align:baseline;}/*!sc*/
textarea{overflow:auto;}/*!sc*/
[type='checkbox'],[type='radio']{box-sizing:border-box;padding:0;}/*!sc*/
[type='number']::-webkit-inner-spin-button,[type='number']::-webkit-outer-spin-button{height:auto;}/*!sc*/
[type='search']{-webkit-appearance:textfield;outline-offset:0;}/*!sc*/
[type='search']::-webkit-search-decoration{-webkit-appearance:none;}/*!sc*/
::-webkit-file-upload-button{-webkit-appearance:button;font:inherit;}/*!sc*/
[type='number']::-webkit-inner-spin-button,[type='number']::-webkit-outer-spin-button{-webkit-appearance:none;margin:0;}/*!sc*/
[type='number']{-moz-appearance:textfield;}/*!sc*/
details{display:block;}/*!sc*/
summary{display:list-item;}/*!sc*/
template{display:none;}/*!sc*/
[hidden]{display:none;}/*!sc*/
*{box-sizing:border-box;}/*!sc*/
html{-webkit-overflow-scrolling:touch;-webkit-scroll-behavior:auto;-moz-scroll-behavior:auto;-ms-scroll-behavior:auto;scroll-behavior:auto;}/*!sc*/
body{min-height:100vh;padding:0;margin:0;background-color:#f1f4f7;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',"Roboto",'Helvetica Neue',"Helvetica","Arial",sans-serif;font-size:16px;line-height:1.5;color:#000;font-variant-ligatures:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;-webkit-overflow-scrolling:touch;overscroll-behavior-y:none;}/*!sc*/
h1,h2,h3,h4,h5,h6,blockquote{line-height:1.15;margin:0;}/*!sc*/
*:focus{outline:none;}/*!sc*/
body.is-keyboard-focused *:focus{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
[inert]{pointer-events:none;cursor:default;}/*!sc*/
[inert],[inert] *{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}/*!sc*/
:root{--reach-slider:1;--reach-dialog:1;--reach-tabs:1;--reach-combobox:1;--reach-menu-button:1;--reach-accordion:1;--reach-skip-nav:1;}/*!sc*/
.custom-css-apply-with-custom-integrations{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;gap:16px;margin-top:16px;margin-bottom:16px;}/*!sc*/
.custom-css-apply-with-custom-integrations:empty{margin-bottom:0;}/*!sc*/
data-styled.g511[id="sc-global-jTVnrn1"]{content:"sc-global-jTVnrn1,"}/*!sc*/
</style>





<meta data-react-helmet="true" content="Careers homepage" name="title"/><meta data-react-helmet="true" content="Careers homepage" property="og:title"/>

<script data-react-helmet="true" data-testid="custom-integrations-window-api">
        window.recruitee = window.recruitee || {};
        window.recruitee.customIntegrationsApi = window.recruitee.customIntegrationsApi || {"companyId":53295,"offerId":null,"offer":null};
      </script>
<title data-react-helmet="true">Careers homepage</title>




    <style>
      body > div[data-component="PublicApp"] {
        display: -webkit-box;
        display: -webkit-flex;
        display: -ms-flexbox;
        display: flex;
        -webkit-flex-direction: column;
        -ms-flex-direction: column;
        flex-direction: column;
        min-height: inherit;
      }
    </style>
  </head>
  <body>
<div data-rendered data-component="PublicApp" data-props="{&quot;appConfig&quot;:{&quot;agreements&quot;:[],&quot;analyticsBaseUrl&quot;:&quot;https://careers-analytics.recruitee.com&quot;,&quot;appEnv&quot;:&quot;production&quot;,&quot;atsHost&quot;:&quot;recruitee.com&quot;,&quot;captcha&quot;:{&quot;apiHost&quot;:&quot;https://captcha-base.recruiteecdn.com&quot;,&quot;assetHost&quot;:&quot;https://captcha-assets.recruiteecdn.com&quot;,&quot;imageHost&quot;:&quot;https://captcha-imgs.recruiteecdn.com&quot;,&quot;reportHost&quot;:&quot;https://captcha-report.recruiteecdn.com&quot;,&quot;siteKey&quot;:&quot;d111bc04-7616-4e05-a1da-9840968d2b88&quot;},&quot;cookiesConsent&quot;:{&quot;isEnabled&quot;:false,&quot;translations&quot;:{&quot;en&quot;:{&quot;agreeToAllCookies&quot;:&quot;Agree to all&quot;,&quot;agreeToNecessaryCookies&quot;:&quot;Agree to necessary&quot;,&quot;agreeToSelectedCookies&quot;:&quot;Agree to selected&quot;,&quot;bigCookiePlaceholderCta&quot;:&quot;Cookie preferences&quot;,&quot;bigCookiePlaceholderTitle&quot;:&quot;But first, cookies ;)&quot;,&quot;bigCookiePlaceholderVimeoDescription&quot;:&quot;We can&#39;t display this video. Please allow Vimeo cookies to watch it.&quot;,&quot;bigCookiePlaceholderYoutubeDescription&quot;:&quot;We can&#39;t display this video. Please allow YouTube cookies to watch it.&quot;,&quot;consentButtonLabel&quot;:null,&quot;description&quot;:null,&quot;dialogDescription&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;We use cookies to ensure that we give you the best experience on our website.&quot;}],&quot;type&quot;:&quot;p&quot;}],&quot;dialogTitle&quot;:&quot;Cookies agreement&quot;,&quot;hideSettings&quot;:&quot;Hide options&quot;,&quot;necessary&quot;:&quot;Necessary&quot;,&quot;necessaryCookies&quot;:&quot;Necessary cookies&quot;,&quot;necessaryCookiesDescription&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Some cookies are required to provide core functionality. The website might not function properly without these cookies, they are enabled by default and cannot be disabled.&quot;}],&quot;type&quot;:&quot;p&quot;}],&quot;optionalCookies&quot;:&quot;Optional cookies&quot;,&quot;showLess&quot;:&quot;Show less&quot;,&quot;showMore&quot;:&quot;Show more&quot;,&quot;showSettings&quot;:&quot;More options&quot;,&quot;smallCookiePlaceholderCta&quot;:&quot;Update cookies&quot;,&quot;smallCookiePlaceholderDescription&quot;:&quot;unavailable&quot;,&quot;title&quot;:null}},&quot;updatedAt&quot;:&quot;2000-01-01T00:00:00&quot;},&quot;customFontFamilies&quot;:[],&quot;departments&quot;:[{&quot;id&quot;:108703,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Development&quot;}}},{&quot;id&quot;:108710,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Administration&quot;}}},{&quot;id&quot;:129247,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;adm&quot;}}},{&quot;id&quot;:108708,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Strategy &amp; Project Management&quot;}}},{&quot;id&quot;:108702,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Design&quot;}}}],&quot;featureFlags&quot;:{&quot;applyWithXing&quot;:true,&quot;careersAnalytics&quot;:true,&quot;customCodeSection&quot;:true,&quot;customIntegrations&quot;:true,&quot;hcaptcha&quot;:true,&quot;internalPages&quot;:true,&quot;jobCoverImage&quot;:true,&quot;manageLocations&quot;:true,&quot;screeningQuestionDate&quot;:true,&quot;siteMigrator&quot;:true,&quot;texting&quot;:true},&quot;initialLocation&quot;:&quot;/&quot;,&quot;internalIntegrations&quot;:[{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;xing&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with XING feature. The Apply with XING feature allows you to apply for jobs by using your XING profile. When you click Apply with XING on our site, we&#39;ll pre-populate some of the job application fields with your profile data and automatically attach your complete XING profile to the application form. This means that we will be able to easily access your complete XING profile as we look through your application. For details about the cookies used and the data received see XING&#39;s Cookie Policy. Apply with XING is subject to XING&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://privacy.xing.com/en/privacy-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:1014388,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;XING&quot;,&quot;type&quot;:&quot;xing&quot;,&quot;updatedAt&quot;:&quot;2024-01-12T12:56:26&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[{&quot;category&quot;:&quot;necessary&quot;,&quot;key&quot;:null,&quot;name&quot;:&quot;_cs_consent&quot;,&quot;provenance&quot;:&quot;first-party&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Stores the user&#39;s cookie consent state for the current domain.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}}],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;careers&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null}}},&quot;id&quot;:458454,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;CareersHub&quot;,&quot;type&quot;:&quot;careers&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;google-analytics&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;We use Google Analytics to track visitor behaviour and measure site performance. For details about the cookies used and the data received see Google&#39;s Cookie Policy. Cookies placed by Google Analytics are subject to Google’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://policies.google.com/technologies/cookies&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458455,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;Google Analytics&quot;,&quot;settings&quot;:{&quot;token&quot;:&quot;&quot;},&quot;type&quot;:&quot;google-analytics&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;youtube&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables embedded YouTube player feature. For details about the cookies used and the data received see Google&#39;s Cookie Policy. Cookies placed by embedded YouTube players are subject to Google’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://policies.google.com/technologies/cookies&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458456,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Youtube&quot;,&quot;type&quot;:&quot;youtube&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;vimeo&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables embedded Vimeo player feature. For details about the cookies used and the data received see Vimeo&#39;s Cookie Policy. Cookies placed by embedded Vimeo players are subject to Vimeo’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://vimeo.com/cookie_policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458457,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Vimeo&quot;,&quot;type&quot;:&quot;vimeo&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;linkedin&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with LinkedIn feature. The Apply with LinkedIn feature allows you to apply for jobs by using your LinkedIn profile. When you click Apply with LinkedIn on our site, we&#39;ll pre-populate some of the job application fields with your profile data and automatically attach your complete LinkedIn profile to the application form. This means that we will be able to easily access your complete LinkedIn profile as we look through your application. For details about the cookies used and the data received see LinkedIn&#39;s Cookie Policy. Apply with LinkedIn is subject to LinkedIn&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.linkedin.com/legal/cookie-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458458,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;LinkedIn&quot;,&quot;settings&quot;:{&quot;isApplyWithLinkedInOn&quot;:true},&quot;type&quot;:&quot;linkedin&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;indeed&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with Indeed feature. The Apply with Indeed feature allows you to quickly apply using an Indeed Resume. For details about the cookies used and the data received see Indeed&#39;s Privacy Policy. Apply with Indeed is subject to Indeed&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Privacy Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.indeed.com/legal&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458459,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Indeed&quot;,&quot;settings&quot;:{&quot;isApplyWithIndeedOn&quot;:true},&quot;type&quot;:&quot;indeed&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;kununu&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables kununu Live Score feature. The kununu Live Score feature allows you to view our current kununu employer score. For details about the cookies used and the data received see kununu&#39;s privacy policy. kununu Live Score is subject to kununu’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Privacy Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://privacy.xing.com/en/privacy-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:680112,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;kununu&quot;,&quot;type&quot;:&quot;kununu&quot;,&quot;updatedAt&quot;:&quot;2021-11-09T16:58:54&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;facebook-pixel&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Allows us to measure the effectiveness of our advertising by understanding the actions that visitors take on our website. For details about the cookies used and the data received see Facebook&#39;s Cookie Policy. Cookies placed by Facebook Pixel are subject to Facebook&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.facebook.com/policies/cookies/&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:811110,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;Facebook Pixel&quot;,&quot;settings&quot;:{&quot;pixelId&quot;:&quot;&quot;},&quot;type&quot;:&quot;facebook-pixel&quot;,&quot;updatedAt&quot;:&quot;2022-06-14T19:53:57&quot;}],&quot;isApplicationFormApplicationDisabled&quot;:null,&quot;isOfferAtsPreview&quot;:null,&quot;isOfferMockFallbackAllowed&quot;:null,&quot;languages&quot;:{&quot;en&quot;:&quot;English&quot;},&quot;offers&quot;:[{&quot;city&quot;:&quot;New York&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108703,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1333509,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;pwpku&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:813298,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91709,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;New York&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;New York&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:42,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;developer-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;sharingDescription&quot;:&quot;Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Developer Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Developer Talent Pool&quot;}}},{&quot;city&quot;:&quot;Brooklyn&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108708,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1357326,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;optional&quot;,&quot;photo&quot;:&quot;off&quot;},&quot;guid&quot;:&quot;u4kva&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:782556,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91708,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;Brooklyn&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;Brooklyn, 11201 (2)&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:&quot;11201&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:&quot;20 Jay Street&quot;}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:false,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:43,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:&quot;USD&quot;,&quot;max&quot;:6.8e4,&quot;min&quot;:5.2e4,&quot;period&quot;:&quot;year&quot;},&quot;slug&quot;:&quot;project-manager-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:&quot;20 Jay Street&quot;,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;sharingDescription&quot;:&quot;We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a &quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Project Manager Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Project Manager Talent Pool&quot;}}},{&quot;city&quot;:&quot;New York&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108702,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1333465,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;2ccy3&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:813299,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91709,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;New York&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;New York&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:41,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;design-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;sharingDescription&quot;:&quot;We are always looking for passionate, talented designers to join our team but don&#39;t always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Design Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Design Talent Pool&quot;}}},{&quot;city&quot;:&quot;BROOKLYN&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:null,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1390320,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;56ucy&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:814442,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91700,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;BROOKLYN&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;BROOKLYN&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:45,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;copywriter-talen-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;sharingDescription&quot;:&quot;Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Copywriter Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Copywriter Talent Pool&quot;}}}],&quot;page&quot;:{&quot;id&quot;:79071,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Careers homepage&quot;,&quot;position&quot;:1,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:251668,&quot;revision&quot;:{&quot;id&quot;:251668,&quot;insertedAt&quot;:&quot;2021-10-19T23:22:49Z&quot;,&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;header&quot;:null,&quot;name&quot;:null,&quot;settings&quot;:{&quot;contentPadding&quot;:&quot;none&quot;,&quot;header&quot;:null,&quot;isHeaderOn&quot;:false,&quot;layout&quot;:&quot;single-column&quot;,&quot;singleColumnLayout&quot;:{&quot;columnAlignment&quot;:&quot;left&quot;,&quot;columnWidth&quot;:12},&quot;textAlignment&quot;:&quot;center&quot;,&quot;textBackgroundColor&quot;:null,&quot;twoColumnLayout&quot;:{&quot;columnGap&quot;:&quot;large&quot;,&quot;columnRatio&quot;:&quot;1:1&quot;,&quot;stretchBackgroundEnabled&quot;:false,&quot;verticalAlignment&quot;:&quot;top&quot;}},&quot;theme&quot;:{&quot;actionColor&quot;:&quot;#fff&quot;,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:{&quot;height&quot;:834,&quot;imageId&quot;:7621,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/HcU/sWb17AUkqGgp.png&quot;,&quot;width&quot;:2288},&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:&quot;image&quot;,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;contentVerticalAlignment&quot;:&quot;center&quot;,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:&quot;#fff&quot;,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:true,&quot;isMinHeightOn&quot;:true,&quot;minHeight&quot;:&quot;medium&quot;,&quot;paddingBottom&quot;:&quot;large&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:&quot;#fff&quot;,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;translations&quot;:{&quot;en&quot;:{&quot;firstColumn&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;type&quot;:&quot;h1&quot;}]},&quot;secondColumn&quot;:{&quot;body&quot;:[],&quot;image&quot;:null}}},&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;e7405c08-6f63-4915-adcf-f85bb4aa397a&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Current openings&quot;}],&quot;type&quot;:&quot;h2&quot;}]}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;areFiltersOn&quot;:null,&quot;areGroupsOn&quot;:false,&quot;areTabsOn&quot;:false,&quot;cardsLayoutSettings&quot;:{&quot;areLanguagesOn&quot;:null,&quot;areTagsOn&quot;:null,&quot;backgroundColor&quot;:null,&quot;buttonPosition&quot;:&quot;aside&quot;,&quot;buttonText&quot;:null,&quot;columns&quot;:2,&quot;gap&quot;:&quot;medium&quot;,&quot;innerPadding&quot;:null,&quot;isButtonOn&quot;:true,&quot;isDepartmentOn&quot;:null,&quot;isLocationCityOn&quot;:null,&quot;isLocationCountryOn&quot;:null,&quot;isLocationNameOn&quot;:null,&quot;isLocationNoteOn&quot;:null,&quot;isLocationOn&quot;:null,&quot;isLocationRemoteOn&quot;:null,&quot;isLocationStateOn&quot;:null,&quot;isLocationStreetOn&quot;:null,&quot;isSalaryOn&quot;:null,&quot;titleSize&quot;:&quot;regular&quot;},&quot;filtersSettings&quot;:{&quot;defaultCountriesPerLanguage&quot;:[],&quot;defaultJobLanguagesPerPageLanguage&quot;:[],&quot;isCityFilterOn&quot;:true,&quot;isCountryFilterOn&quot;:true,&quot;isDepartmentFilterOn&quot;:false,&quot;isHeadingOn&quot;:true,&quot;isLanguageFilterOn&quot;:null,&quot;isRemoteFilterOn&quot;:null,&quot;isSearchOn&quot;:true,&quot;isStateFilterOn&quot;:false,&quot;isTagFilterOn&quot;:false,&quot;layout&quot;:&quot;boxed&quot;,&quot;position&quot;:&quot;top&quot;},&quot;groupsSettings&quot;:{&quot;groupBy&quot;:null,&quot;jobCounterVariant&quot;:null,&quot;position&quot;:null},&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:null,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:null,&quot;horizontalLayoutWidth&quot;:null,&quot;isBackgroundStretchOn&quot;:null,&quot;isCustomColored&quot;:null,&quot;padding&quot;:null,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:null,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:null,&quot;verticalLayoutWidth&quot;:null},&quot;isHeaderOn&quot;:true,&quot;isPaginationOn&quot;:null,&quot;layout&quot;:&quot;table&quot;,&quot;paginationSettings&quot;:null,&quot;prefiltersSettings&quot;:null,&quot;sortBy&quot;:null,&quot;tableLayoutSettings&quot;:{&quot;buttonText&quot;:null,&quot;isButtonOn&quot;:true,&quot;isDepartmentColumnOn&quot;:null,&quot;isLanguagesColumnOn&quot;:null,&quot;isLocationCityOn&quot;:null,&quot;isLocationColumnOn&quot;:false,&quot;isLocationCountryOn&quot;:null,&quot;isLocationNameOn&quot;:null,&quot;isLocationNoteOn&quot;:null,&quot;isLocationRemoteOn&quot;:null,&quot;isLocationStateOn&quot;:null,&quot;isLocationStreetOn&quot;:null,&quot;isSalaryColumnOn&quot;:null,&quot;isTagsColumnOn&quot;:null,&quot;spacing&quot;:&quot;spacious&quot;},&quot;tabsSettings&quot;:{&quot;jobCounterVariant&quot;:null,&quot;position&quot;:&quot;top&quot;,&quot;size&quot;:&quot;regular&quot;,&quot;tabBy&quot;:null}},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:null,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:&quot;top&quot;,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:true,&quot;minHeight&quot;:&quot;small&quot;,&quot;paddingBottom&quot;:&quot;large&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;OfferList&quot;,&quot;uuid&quot;:&quot;c88dea0d-b17f-4245-a020-9167e1e2bac0&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Our Philosophy&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We have a lot of fun together, something we consider to be really important. The creative process isn’t easy, but enjoying the journey is something we do well. We love what we do, and we think you’ll love working with us.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;image&quot;:{&quot;image&quot;:{&quot;height&quot;:1080,&quot;imageId&quot;:8800,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/ImA/Z18mPRgadPTx.jpeg&quot;,&quot;width&quot;:1080},&quot;translations&quot;:{&quot;en&quot;:{&quot;alt&quot;:&quot;some text&quot;}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;customImageWidth&quot;:100,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;left&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/2&quot;,&quot;isBackgroundStretchOn&quot;:true,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;extra-large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;left&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;center&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;horizontalAlignment&quot;:&quot;center&quot;,&quot;imageWidth&quot;:&quot;custom&quot;,&quot;isHeaderOn&quot;:true},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;small&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;fb8d4333-6abd-414e-aa18-d639f3f169ef&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Our Clients&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;From powerhouses like the Brooklyn Navy Yard, Sesame Workshop, Vital Strategies, and Columbia University, to global movers and shakers like The American Cancer Society, United Nations, the International Rescue Committee, UNICEF, and Women’s Refugee Commission, we’ve worked together to solve some big problems and increase their impact.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;image&quot;:{&quot;image&quot;:{&quot;height&quot;:1080,&quot;imageId&quot;:8801,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/ImE/pqy0lEe95RqO.jpeg&quot;,&quot;width&quot;:1080},&quot;translations&quot;:{&quot;en&quot;:{&quot;alt&quot;:&quot;some text&quot;}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;customImageWidth&quot;:100,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;right&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/2&quot;,&quot;isBackgroundStretchOn&quot;:true,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;extra-large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;left&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;center&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;horizontalAlignment&quot;:&quot;center&quot;,&quot;imageWidth&quot;:&quot;custom&quot;,&quot;isHeaderOn&quot;:true},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;medium&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;c316b05d-aac8-4c48-995f-5b177342df19&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:null,&quot;name&quot;:null,&quot;settings&quot;:{&quot;contentPadding&quot;:&quot;small&quot;,&quot;header&quot;:null,&quot;isHeaderOn&quot;:false,&quot;layout&quot;:&quot;single-column&quot;,&quot;singleColumnLayout&quot;:{&quot;columnAlignment&quot;:&quot;center&quot;,&quot;columnWidth&quot;:12},&quot;textAlignment&quot;:&quot;left&quot;,&quot;textBackgroundColor&quot;:null,&quot;twoColumnLayout&quot;:{&quot;columnGap&quot;:&quot;small&quot;,&quot;columnRatio&quot;:&quot;1:1&quot;,&quot;stretchBackgroundEnabled&quot;:false,&quot;verticalAlignment&quot;:&quot;center&quot;}},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;translations&quot;:{&quot;en&quot;:{&quot;firstColumn&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_self&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;/&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;Join a team of kind, curious, and empathetic individuals&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Radish Lab is a creative agency that believes that good design can help solve big challenges. We partner with organizations that are looking to create greater impact in their work and the world around them.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We believe good design is clear, simple, and engaging. And we believe that good design has the power to move you.We focus on helping social change projects and organizations tell compelling digital stories, deeply engage their audiences, and apply smart creative and technical solutions to some pretty impressive challenges.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;With offices in Brooklyn and Berlin, we love helping our clients create and tell compelling visual stories. &quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Radish Lab is also a certified B Corporation, which means we’re held accountable for meeting the highest standards of overall social and environmental performance, transparency and accountability.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;type&quot;:&quot;p&quot;}]},&quot;secondColumn&quot;:{&quot;body&quot;:[],&quot;image&quot;:null}}},&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;f4523764-61b1-476e-9c60-90a3171bc222&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;SELECTED CLIENTS&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We partner with organizations, activists and optimists. Here’s a handful we’ve already helped.&quot;}],&quot;type&quot;:&quot;h3&quot;}]}}},&quot;items&quot;:[{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8792,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilg/KFkAhPsAE6m7.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8793,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilk/lVkUsYEyvKky.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8794,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilo/S5EkxjRNYf4U.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8795,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ils/UcXAqrsyzCFC.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8796,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilw/5vZK251ADpLK.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8797,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il0/mJUUpYFqt7ny.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8798,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il4/J3g5SeRl41JZ.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8799,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il8/pXhL2Ip7Ng1z.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null}],&quot;name&quot;:null,&quot;settings&quot;:{&quot;borderRadius&quot;:0,&quot;carousel&quot;:null,&quot;columnCount&quot;:4,&quot;gap&quot;:&quot;small&quot;,&quot;grid&quot;:{&quot;emphasizedItems&quot;:[{&quot;columnCount&quot;:2,&quot;settings&quot;:[{&quot;columnIndex&quot;:0,&quot;rowIndex&quot;:1},{&quot;columnIndex&quot;:0,&quot;rowIndex&quot;:2}]},{&quot;columnCount&quot;:3,&quot;settings&quot;:[{&quot;columnIndex&quot;:1,&quot;rowIndex&quot;:1},{&quot;columnIndex&quot;:1,&quot;rowIndex&quot;:2},{&quot;columnIndex&quot;:2,&quot;rowIndex&quot;:0}]}]},&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;medium&quot;,&quot;headerPosition&quot;:&quot;top&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/4&quot;,&quot;isBackgroundStretchOn&quot;:false,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;none&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;center&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;top&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;isHeaderOn&quot;:true,&quot;isLightboxOn&quot;:null,&quot;layout&quot;:&quot;grid&quot;,&quot;masonry&quot;:{&quot;heightSettings&quot;:{&quot;firstRow&quot;:[{&quot;columnIndex&quot;:1,&quot;heightMultiplier&quot;:1.0},{&quot;columnIndex&quot;:3,&quot;heightMultiplier&quot;:1.5}],&quot;lastRow&quot;:[{&quot;columnIndex&quot;:0,&quot;heightMultiplier&quot;:1.0},{&quot;columnIndex&quot;:1,&quot;heightMultiplier&quot;:1.0}]},&quot;widthSettings&quot;:[{&quot;columnCount&quot;:2,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[4,8],&quot;rowIndex&quot;:0}]},{&quot;columnCount&quot;:3,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[3,4,5],&quot;rowIndex&quot;:0}]},{&quot;columnCount&quot;:4,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[4,2,2,4],&quot;rowIndex&quot;:0}]}]},&quot;rowAlignment&quot;:&quot;center&quot;},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:&quot;center&quot;,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;ImageCollection&quot;,&quot;uuid&quot;:&quot;6808b50d-8984-4888-8f76-4fbff8bb3e67&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;OUR OFFICE&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Brooklyn – DUMBO&quot;}],&quot;type&quot;:&quot;h3&quot;}]}}},&quot;map&quot;:{&quot;markers&quot;:[{&quot;address&quot;:&quot;20 Jay Street, Brooklyn, New York 11201, United States&quot;,&quot;latitude&quot;:&quot;40.704097&quot;,&quot;longitude&quot;:&quot;-73.98688&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:&quot;&quot;,&quot;title&quot;:&quot;Brooklyn&quot;}}}]},&quot;name&quot;:null,&quot;settings&quot;:{&quot;areMapControlsOn&quot;:true,&quot;gap&quot;:&quot;small&quot;,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;top&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/4&quot;,&quot;isBackgroundStretchOn&quot;:false,&quot;isCustomColored&quot;:null,&quot;padding&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;center&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;top&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;isHeaderOn&quot;:true,&quot;mapAlignment&quot;:&quot;center&quot;,&quot;mapHeight&quot;:&quot;medium&quot;,&quot;mapTilesStyle&quot;:&quot;streets-v11&quot;,&quot;mapWidth&quot;:12},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:&quot;center&quot;,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;medium&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Map&quot;,&quot;uuid&quot;:&quot;cb09dc8f-0334-4c29-9278-7141395f4bf7&quot;}]},&quot;slug&quot;:&quot;homepage&quot;,&quot;status&quot;:&quot;published&quot;,&quot;theme&quot;:{&quot;actionColor&quot;:&quot;#000000&quot;,&quot;backgroundColor&quot;:&quot;#fff&quot;,&quot;buttonFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;buttonFontStyle&quot;:null,&quot;buttonFontTransform&quot;:null,&quot;buttonFontWeight&quot;:&quot;600&quot;,&quot;default&quot;:true,&quot;footer&quot;:{&quot;areLinksOn&quot;:false,&quot;areSocialLinksOn&quot;:false,&quot;isFooterOn&quot;:null,&quot;languagePicker&quot;:null,&quot;links&quot;:[],&quot;logo&quot;:null,&quot;logoLink&quot;:null,&quot;logoMaxHeight&quot;:null,&quot;logoWithAlt&quot;:null,&quot;socialLinks&quot;:[],&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:null,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:null,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:null,&quot;paddingTop&quot;:null,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null}},&quot;headingColor&quot;:&quot;#000000&quot;,&quot;headingFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;headingFontStyle&quot;:null,&quot;headingFontTransform&quot;:null,&quot;headingFontWeight&quot;:&quot;600&quot;,&quot;id&quot;:39544,&quot;name&quot;:&quot;Default&quot;,&quot;navigation&quot;:{&quot;button&quot;:null,&quot;colorSchemeSource&quot;:null,&quot;contentBoundary&quot;:null,&quot;fixedNavigationLogo&quot;:null,&quot;fixedNavigationLogoWithAlt&quot;:null,&quot;fixedNavigationTheme&quot;:null,&quot;fixedNavigationType&quot;:null,&quot;isFixed&quot;:null,&quot;languagePicker&quot;:null,&quot;layout&quot;:null,&quot;links&quot;:[{&quot;items&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null,&quot;label&quot;:&quot;Company website&quot;,&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:null,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.radishlab.com/&quot;},&quot;url&quot;:null}},&quot;type&quot;:null}],&quot;logo&quot;:{&quot;height&quot;:312,&quot;imageId&quot;:10003,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/JxM/erKO0TGNyJ6_.png&quot;,&quot;width&quot;:1118},&quot;logoLink&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null,&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:79071,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:null,&quot;type&quot;:&quot;page&quot;,&quot;url&quot;:null}}}},&quot;logoMaxHeight&quot;:null,&quot;logoWithAlt&quot;:null,&quot;socialLinks&quot;:[{&quot;translations&quot;:{&quot;en&quot;:{&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:null,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.instagram.com/radishlab/&quot;},&quot;url&quot;:null}},&quot;type&quot;:&quot;instagram&quot;}],&quot;theme&quot;:null},&quot;pageIds&quot;:[79072,281476,79071],&quot;primaryButtonTextColor&quot;:null,&quot;recruiteeBranding&quot;:null,&quot;textColor&quot;:&quot;#000000&quot;,&quot;textFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;textFontSize&quot;:null,&quot;textFontStyle&quot;:null,&quot;textFontTransform&quot;:null,&quot;textFontWeight&quot;:&quot;400&quot;},&quot;translations&quot;:{},&quot;type&quot;:&quot;homepage&quot;,&quot;visibility&quot;:&quot;public&quot;},&quot;pages&quot;:[{&quot;id&quot;:79071,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Careers homepage&quot;,&quot;position&quot;:1,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:251668,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;e7405c08-6f63-4915-adcf-f85bb4aa397a&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;OfferList&quot;,&quot;uuid&quot;:&quot;c88dea0d-b17f-4245-a020-9167e1e2bac0&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;fb8d4333-6abd-414e-aa18-d639f3f169ef&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;c316b05d-aac8-4c48-995f-5b177342df19&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;f4523764-61b1-476e-9c60-90a3171bc222&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;ImageCollection&quot;,&quot;uuid&quot;:&quot;6808b50d-8984-4888-8f76-4fbff8bb3e67&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Map&quot;,&quot;uuid&quot;:&quot;cb09dc8f-0334-4c29-9278-7141395f4bf7&quot;}]},&quot;slug&quot;:&quot;homepage&quot;,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;homepage&quot;,&quot;visibility&quot;:&quot;public&quot;},{&quot;id&quot;:79072,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Offer details&quot;,&quot;position&quot;:2,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:250726,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;OfferHeadline&quot;,&quot;uuid&quot;:&quot;a8e9c04b-733b-4245-b54f-45e388a6d718&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Offer&quot;,&quot;uuid&quot;:&quot;fd8097f3-6dc5-4dff-96ab-ff3e71e23837&quot;}]},&quot;slug&quot;:null,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;offer_details&quot;,&quot;visibility&quot;:&quot;public&quot;},{&quot;id&quot;:281476,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;We couldn&#39;t find this job&quot;,&quot;position&quot;:0,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:409485,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;JobNotFound&quot;,&quot;uuid&quot;:null}]},&quot;slug&quot;:null,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;job_not_found&quot;,&quot;visibility&quot;:&quot;public&quot;}],&quot;sentryEnv&quot;:&quot;production&quot;,&quot;site&quot;:{&quot;advancedSettings&quot;:{&quot;internalJobsListing&quot;:&quot;disabled&quot;},&quot;awliApiKey&quot;:null,&quot;awliIntegrationContext&quot;:null,&quot;captcha&quot;:&quot;invisible&quot;,&quot;careersAnalyticsEnabled&quot;:true,&quot;companyLangCodes&quot;:[&quot;en&quot;],&quot;cookieConsentEnabled&quot;:false,&quot;customCss&quot;:null,&quot;customHtmlBody&quot;:null,&quot;customHtmlHead&quot;:null,&quot;defaultOgImageUrl&quot;:&quot;https://careers.recruiteecdn.com/image/upload/share_image_w6am4m.png&quot;,&quot;domainActivated&quot;:false,&quot;eeo&quot;:{&quot;isEnabled&quot;:false,&quot;kind&quot;:&quot;eeo&quot;},&quot;externalId&quot;:53295,&quot;host&quot;:&quot;radishlab.recruitee.com&quot;,&quot;id&quot;:39590,&quot;kununuHash&quot;:null,&quot;kununuLink&quot;:null,&quot;langCodes&quot;:[&quot;en&quot;],&quot;migrationDate&quot;:null,&quot;name&quot;:&quot;Radish Lab&quot;,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publicTranslations&quot;:{&quot;en&quot;:{&quot;shareFilteredJobsList&quot;:&quot;Share filtered jobs list&quot;,&quot;allCities&quot;:&quot;All cities&quot;,&quot;applicationSuccessDescription&quot;:&quot;Your application has been successfully submitted!&quot;,&quot;carouselPreviousSlideLabel&quot;:&quot;Previous slide&quot;,&quot;allDepartments&quot;:&quot;All departments&quot;,&quot;remote&quot;:&quot;Remote&quot;,&quot;stateFilterLabel&quot;:&quot;Select states/regions to filter offers by&quot;,&quot;allLanguages&quot;:&quot;All languages&quot;,&quot;xingCvNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;searchOffersLabel&quot;:&quot;Enter search query to filter offers by&quot;,&quot;cvFormatAllowedExtensions&quot;:&quot;Accepted files: PDF, DOC, DOCX, JPEG and PNG up to 50MB.&quot;,&quot;workModelFilterLabel&quot;:&quot;Select work model to filter offers by&quot;,&quot;shareJob&quot;:&quot;Share job&quot;,&quot;tooLargeFile&quot;:&quot;This file is too large&quot;,&quot;languages&quot;:&quot;Available languages&quot;,&quot;skipToContent&quot;:&quot;Skip to content&quot;,&quot;xingNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;departmentFilterLabel&quot;:&quot;Select departments to filter offers by&quot;,&quot;dragAndDrop&quot;:&quot;or drag and drop here&quot;,&quot;xingClearProfileData&quot;:&quot;Clear profile data&quot;,&quot;clearTextAndUploadFile&quot;:&quot;Clear text and upload a file instead&quot;,&quot;xJobs&quot;:&quot;%{jobsCount} jobs&quot;,&quot;viewJob&quot;:&quot;View job&quot;,&quot;jobDoesntExist&quot;:&quot;This job doesn’t exist or was removed.&quot;,&quot;emailPlaceholder&quot;:&quot;Your email address&quot;,&quot;offerTitle&quot;:&quot;Job title&quot;,&quot;textingConsent&quot;:&quot;I consent to be contacted via text messages for this and any other job within %{companyName}.&quot;,&quot;phonePlaceholder&quot;:&quot;Your phone number&quot;,&quot;applicationSuccessHeading&quot;:&quot;All done!&quot;,&quot;xMore&quot;:&quot;%{count} more&quot;,&quot;orApplyWith&quot;:&quot;or&quot;,&quot;carouselNextSlideLabel&quot;:&quot;Next slide&quot;,&quot;insertEmailAddress&quot;:&quot;This email address is invalid. Please enter a valid email address (for example, name@example.com).&quot;,&quot;yesAnswer&quot;:&quot;Yes&quot;,&quot;hybrid&quot;:&quot;Hybrid&quot;,&quot;perYear&quot;:&quot;%{range} per year&quot;,&quot;applicationSuccessButtonLabel&quot;:&quot;Other jobs&quot;,&quot;locationNoteTooltip&quot;:&quot;Location note tooltip&quot;,&quot;agreementsLabel&quot;:&quot;Legal Agreements&quot;,&quot;phoneLabel&quot;:&quot;Phone number&quot;,&quot;emptyPage&quot;:&quot;This page is empty&quot;,&quot;city&quot;:&quot;City&quot;,&quot;clearFilters&quot;:&quot;Clear&quot;,&quot;extensionError&quot;:&quot;allowed file types&quot;,&quot;offerListNoOffers&quot;:&quot;Currently we don&#39;t have any open positions.&quot;,&quot;salary&quot;:&quot;Salary&quot;,&quot;personalInformationHint&quot;:&quot;Fill out the information below&quot;,&quot;insertValidPhoneNumber&quot;:&quot;This phone number is invalid. Please enter a valid phone number, including the country calling code.&quot;,&quot;applyForm&quot;:&quot;Application&quot;,&quot;coverLetterButtonWriteHere&quot;:&quot;Write it here instead&quot;,&quot;international&quot;:&quot;International&quot;,&quot;enterText&quot;:&quot;Enter text&quot;,&quot;linkedInNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;coverLetterLabel&quot;:&quot;Cover letter&quot;,&quot;languageFilterLabel&quot;:&quot;Select languages to filter offers by&quot;,&quot;requiredFieldsDescription&quot;:&quot;All fields marked with * are required.&quot;,&quot;questionsHint&quot;:&quot;Please fill in additional questions&quot;,&quot;cvLabel&quot;:&quot;CV or resume&quot;,&quot;showFiltersButtonText&quot;:&quot;Show filters&quot;,&quot;imageCollectionEmptyDescription&quot;:&quot;Image collection is empty&quot;,&quot;cvHint&quot;:&quot;Upload your CV or resume file&quot;,&quot;jobNotFound&quot;:&quot;We couldn’t find this job&quot;,&quot;tooManyFiles&quot;:&quot;Too many files&quot;,&quot;questionsLabel&quot;:&quot;Questions&quot;,&quot;showMoreJobs&quot;:&quot;Show more jobs&quot;,&quot;send&quot;:&quot;Send&quot;,&quot;location&quot;:&quot;Location&quot;,&quot;workModel&quot;:&quot;Work model&quot;,&quot;applied&quot;:&quot;Applied&quot;,&quot;allStates&quot;:&quot;All states/regions&quot;,&quot;offerListNoOffersMatchingFilters&quot;:&quot;No open positions matching selected filters.&quot;,&quot;offerListFiltersHeading&quot;:&quot;Filters&quot;,&quot;copied&quot;:&quot;Copied&quot;,&quot;tags&quot;:&quot;Tags&quot;,&quot;showingXOfY&quot;:&quot;Showing %{visibleJobsCount} of %{jobsCount}&quot;,&quot;coverLetterButtonClearAndUpload&quot;:&quot;Clear and upload a cover letter instead&quot;,&quot;coverLetterHint&quot;:&quot;Insert your cover letter here&quot;,&quot;applyWithIndeed&quot;:&quot;Apply with Indeed&quot;,&quot;fieldRequired&quot;:&quot;This field is required and can not be left empty.&quot;,&quot;details&quot;:&quot;Details&quot;,&quot;clearDateButton&quot;:&quot;Clear&quot;,&quot;onSite&quot;:&quot;On-site&quot;,&quot;department&quot;:&quot;Department&quot;,&quot;tag&quot;:&quot;Tag&quot;,&quot;perHour&quot;:&quot;%{range} per hour&quot;,&quot;namePlaceholder&quot;:&quot;Full name&quot;,&quot;uploadFile&quot;:&quot;Upload a file&quot;,&quot;hideFiltersButtonText&quot;:&quot;Hide filters&quot;,&quot;applyWithXing&quot;:&quot;Apply With XING&quot;,&quot;close&quot;:&quot;Close&quot;,&quot;homepage&quot;:&quot;Homepage&quot;,&quot;countryFilterLabel&quot;:&quot;Select countries to filter offers by&quot;,&quot;offerRequirements&quot;:&quot;Job requirements&quot;,&quot;offerDescription&quot;:&quot;Job description&quot;,&quot;present&quot;:&quot;Present&quot;,&quot;noAnswer&quot;:&quot;No&quot;,&quot;allTags&quot;:&quot;All tags&quot;,&quot;coverLetterHintFileUpload&quot;:&quot;Upload your cover letter&quot;,&quot;country&quot;:&quot;Country&quot;,&quot;changeFile&quot;:&quot;Change file&quot;,&quot;shareTo&quot;:&quot;Share to&quot;,&quot;nameLabel&quot;:&quot;Full name&quot;,&quot;filenameBlankError&quot;:&quot;Filename can&#39;t be blank&quot;,&quot;link&quot;:&quot;Link&quot;,&quot;offerListTabsLabel&quot;:&quot;Select tab to filter offers by&quot;,&quot;searchOffers&quot;:&quot;Search offers...&quot;,&quot;play&quot;:&quot;Play&quot;,&quot;goToHomepage&quot;:&quot;Go to homepage&quot;,&quot;remoteJob&quot;:&quot;Remote job&quot;,&quot;linkedInCvNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;noDepartment&quot;:&quot;No department&quot;,&quot;unsafeError&quot;:&quot;is unsafe&quot;,&quot;copy&quot;:&quot;Copy&quot;,&quot;linkedInClearProfileData&quot;:&quot;Clear profile data&quot;,&quot;invalidError&quot;:&quot;is invalid&quot;,&quot;applyWith&quot;:&quot;Apply with&quot;,&quot;blankError&quot;:&quot;can&#39;t be blank&quot;,&quot;phoneCallingCodeLabel&quot;:&quot;Select country calling code&quot;,&quot;photoLabel&quot;:&quot;Photo&quot;,&quot;allCountries&quot;:&quot;All countries&quot;,&quot;removeFile&quot;:&quot;Remove&quot;,&quot;invalidFileType&quot;:&quot;Invalid file type&quot;,&quot;tagFilterLabel&quot;:&quot;Select tags to filter offers by&quot;,&quot;emailLabel&quot;:&quot;Email address&quot;,&quot;apply&quot;:&quot;Apply&quot;,&quot;offerListNoOffersMatchingPrefilters&quot;:&quot;No open positions.&quot;,&quot;departments&quot;:&quot;Departments&quot;,&quot;moreLocationsTooltip&quot;:&quot;More locations tooltip&quot;,&quot;perMonth&quot;:&quot;%{range} per month&quot;,&quot;share&quot;:&quot;Share&quot;,&quot;skipToCookieConsent&quot;:&quot;Skip to Cookie Consent&quot;,&quot;photoFormatAllowedExtensions&quot;:&quot;Accepted files: PNG, JPG and JPEG up to 20MB.&quot;,&quot;textingConsentHeader&quot;:&quot;SMS consent&quot;,&quot;pageNavigationLabel&quot;:&quot;Page navigation&quot;,&quot;cityFilterLabel&quot;:&quot;Select cities to filter offers by&quot;,&quot;personalInformationLabel&quot;:&quot;My information&quot;,&quot;noState&quot;:&quot;No state/region&quot;,&quot;state&quot;:&quot;State&quot;,&quot;coverLetterFileAllowedFormats&quot;:&quot;We accept PDF, DOC, DOCX, JPG and PNG files.&quot;,&quot;coverLetterHintTextArea&quot;:&quot;Write your cover letter here&quot;,&quot;offerDetails&quot;:&quot;Job details&quot;}},&quot;redirectToCustomDomain&quot;:true,&quot;subdomain&quot;:&quot;radishlab&quot;,&quot;textingSettingsEnabled&quot;:false,&quot;translations&quot;:{&quot;en&quot;:{&quot;ogImage&quot;:{&quot;height&quot;:418,&quot;imageId&quot;:66150,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/AQJm/eTpqtQ6sZ9sc.jpeg&quot;,&quot;width&quot;:800}}},&quot;updatedAt&quot;:&quot;2024-06-25T17:45:49&quot;}}}"><div></div><div class="sc-q8cmux-0 gBDROR"><a class="sc-q8cmux-1 kJsRIK" href="#content" data-reach-skip-link="" data-reach-skip-nav-link="">Skip to content</a></div><div class="sc-73r8cv-1 ilRiFP"><div data-scroll-point="section-navigation"><div class="sc-z9o81a-0 kllnfT"><div class="sc-z9o81a-1 fsBFXt"><div data-cy="navigation-section-position" style="font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;color:#fff;background-color:rgba(0, 0, 0, 0)" class="sc-3k6t01-0 jLGbJs"><div data-cy="navigation-section-grid-container" class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-0 dYPHZW"><div class="sc-1aabq8s-0 sc-1aabq8s-1 kJLltb"><a class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo" href="/"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" data-cy="navigation-section-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></a><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 kpwRdG"><nav><ul class="sc-1aabq8s-2 sc-1aabq8s-3 sc-1xewqye-0 hdTF"><li class="sc-1aabq8s-4 kcKagb"><a data-cy="navigation-section-link-item" href="https://www.radishlab.com/" target="_blank" rel="noopener" class="sc-ir8rf5-0 dPcHAE">Company website</a></li><li class="sc-1aabq8s-4 kcKagb"><a data-cy="navigation-section-social-link-item" href="https://www.instagram.com/radishlab/" target="_blank" title="instagram" rel="noopener" class="sc-7glywv-0 hlNgLl"><span class="sc-1rd450u-0 bIScAX"><svg width="18" height="18" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></a></li></ul></nav></div></div><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-1 ciZwhu"><div class="sc-1aabq8s-0 sc-1aabq8s-1 sc-1hkznj2-0 cghDST"><a class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo" href="/"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" data-cy="navigation-section-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></a><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 sc-1hkznj2-1 guEbMs"><div class="sc-1tx5im8-0 iudIDi"><button aria-live="polite" type="button" aria-haspopup="true" aria-controls="menu" aria-label="Page navigation" data-reach-menu-button="" class="sc-s03za1-0 eDCgIN sc-1km6n6q-1 sc-1tu9xny-2 iPvmIC"><span class="sc-1rd450u-0 bIScAX"><svg height="12" width="18" viewBox="0 0 18 12"><path d="M0 12h18v-2H0v2Zm0-5h18V5H0v2Zm0-7v2h18V0H0Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg></span></button><div data-reach-menu="" data-reach-menu-popover="" hidden="" class="sc-1tu9xny-4 sc-1tx5im8-1 hBOHsL"><div role="menu" tabindex="-1" data-reach-menu-items="" id="menu" style="background-color:#fff" class="sc-1tu9xny-0 hLPFpI"><div role="none" tabindex="-1"><a role="menuitem" tabindex="-1" href="https://www.radishlab.com/" target="_blank" data-reach-menu-link="" data-reach-menu-item="" data-selected="" data-valuetext="" class="sc-1tu9xny-1 kZTElj">Company website</a></div><div role="none" tabindex="-1"><a role="menuitem" tabindex="-1" href="https://www.instagram.com/radishlab/" aria-label="instagram" target="_BLANK" rel="noopener" style="display:inline-flex" data-reach-menu-link="" data-reach-menu-item="" data-selected="" data-valuetext="" class="sc-1tu9xny-1 kZTElj"><span class="sc-1rd450u-0 bIScAX"><svg width="15" height="15" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></a></div></div></div></div></div></div></div></div></div></div></div></div><div id="content" data-reach-skip-nav-content=""></div><main class="sc-73r8cv-0 homvAg"><div data-scroll-point="section-text-e7405c08"><section class="sc-gfrfnr-0 gJxpwG custom-css-style-first-section custom-css-section-e7405c08" data-cy="section-background-wrapper" style="background-color:#fff"><div class="sc-gfrfnr-2 deOrHQ"><div class="sc-1oxti4r-0 ixGbOy"><img data-cy="section-background-image" role="presentation" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/HcU/sWb17AUkqGgp.png" alt="" class="sc-itprxg-0 UZqcu"/></div><div class="sc-gfrfnr-1 iVfIXi custom-css-style-first-section-background"></div></div><div class="sc-18h7are-0 ebVyJP"><div role="presentation" inert="true" aria-hidden="true" class="sc-lqj8ks-0 hfKXfE"><div style="font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;color:#fff;background-color:rgba(0, 0, 0, 0)" class="sc-3k6t01-0 jLGbJs"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-0 dYPHZW"><div class="sc-1aabq8s-0 sc-1aabq8s-1 kJLltb"><div class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></div><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 kpwRdG"><nav><ul class="sc-1aabq8s-2 sc-1aabq8s-3 sc-1xewqye-0 hdTF"><li class="sc-1aabq8s-4 kcKagb"><div class="sc-ir8rf5-0 dPcHAE">Company website</div></li><li class="sc-1aabq8s-4 kcKagb"><div title="instagram" class="sc-7glywv-0 hlNgLl"><span class="sc-1rd450u-0 bIScAX"><svg width="18" height="18" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></div></li></ul></nav></div></div><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-1 ciZwhu"><div class="sc-1aabq8s-0 sc-1aabq8s-1 sc-1hkznj2-0 cghDST"><div class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></div><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 sc-1hkznj2-1 guEbMs"><div class="sc-s03za1-0 jmbcoz sc-1tu9xny-3 cAzrSG"><span class="sc-1rd450u-0 bIScAX"><svg height="12" width="18" viewBox="0 0 18 12"><path d="M0 12h18v-2H0v2Zm0-5h18V5H0v2Zm0-7v2h18V0H0Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg></span></div></div></div></div></div></div></div><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 guycoN"><div style="color:#fff;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><p class="sc-1we8l0o-2 dPLHJJ"></p></div></div></div></div></div></section></div><div data-scroll-point="section-jobs-c88dea0d"><section class="sc-gfrfnr-0 gQRcOO custom-css-section-c88dea0d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 bSaXtg"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 guycoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 bEnYHY"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h2 data-slate-node="element" class="sc-1npqnwg-2 sc-1npqnwg-3 eFVUhY slate-h2"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Current openings</span></span></span></h2></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div><div class="sc-4j8eof-0 dPfocN"><div data-testid="offer-list-grid" class="sc-1mxcttb-0 dWcJRW"><div class="sc-4j8eof-1 jFfmvQ"><div class="sc-4j8eof-2 iOxTuT"><output class="sc-1mxcttb-2 fDKnQQ"><div class="sc-1dywz0m-0 exQcZ"><div class="sc-1qe5ahw-0 ffHrMJ"><div class="sc-18rtkup-1 hhapWv"><table class="sc-18rtkup-0 bJoAoi"><thead><tr><th style="width:50%">Job title</th><th style="width:50%">Work model</th><th></th></tr></thead><tbody><tr><td><a href="/o/copywriter-talen-pool" class="sc-18rtkup-2 bqJcqI">Copywriter Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/copywriter-talen-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/design-talent-pool" class="sc-18rtkup-2 bqJcqI">Design Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/design-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/developer-talent-pool" class="sc-18rtkup-2 bqJcqI">Developer Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/developer-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/project-manager-talent-pool" class="sc-18rtkup-2 bqJcqI">Project Manager Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/project-manager-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr></tbody></table></div></div></div><div class="sc-1dywz0m-1 gcbsVn"><div class="sc-465zle-0 brHqfD"><div class="sc-465zle-1 fTGeMR"><a href="/o/copywriter-talen-pool" class="sc-465zle-2 bCpqiX">Copywriter Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/copywriter-talen-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/design-talent-pool" class="sc-465zle-2 bCpqiX">Design Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/design-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/developer-talent-pool" class="sc-465zle-2 bCpqiX">Developer Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/developer-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/project-manager-talent-pool" class="sc-465zle-2 bCpqiX">Project Manager Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/project-manager-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div></div></div></output></div></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-image-fb8d4333"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-fb8d4333" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 gZDsxt"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 sc-bq9z91-0 iOQKaL"><div class="sc-1dj1hqi-2 hPupHS"><div class="sc-pelm1o-0 hYJywo"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Our Philosophy</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We have a lot of fun together, something we consider to be really important. The creative process isn’t easy, but enjoying the journey is something we do well. We love what we do, and we think you’ll love working with us.</span></span></span></p></div></div></div></div></div></div><div class="sc-1dj1hqi-2 fXdQP"><div class="sc-11gkm9w-0 lcroFG"><div class="sc-11gkm9w-1 YAzbZ"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img class="sc-146moy0-0 cTyKMn" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/ImA/Z18mPRgadPTx.jpeg" alt="some text" loading="lazy" width="1080" height="1080"/></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-image-c316b05d"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-c316b05d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 kdUgoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 sc-bq9z91-0 OebVS"><div class="sc-1dj1hqi-2 hPupHS"><div class="sc-pelm1o-0 hYJywo"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Our Clients</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">From powerhouses like the Brooklyn Navy Yard, Sesame Workshop, Vital Strategies, and Columbia University, to global movers and shakers like The American Cancer Society, United Nations, the International Rescue Committee, UNICEF, and Women’s Refugee Commission, we’ve worked together to solve some big problems and increase their impact.</span></span></span></p></div></div></div></div></div></div><div class="sc-1dj1hqi-2 fXdQP"><div class="sc-11gkm9w-0 lcroFG"><div class="sc-11gkm9w-1 YAzbZ"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img class="sc-146moy0-0 cTyKMn" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/ImE/pqy0lEe95RqO.jpeg" alt="some text" loading="lazy" width="1080" height="1080"/></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-text-f4523764"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-f4523764" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 hacApq"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1we8l0o-0 iZuBTr"><article class="sc-1we8l0o-1 kNKRnF"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="z" data-slate-length="0">﻿</span></span></span><a data-slate-node="element" data-slate-inline="true" href="/" target="_self" data-link="{&quot;target&quot;:&quot;_self&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;/&quot;}" class="sc-5egf6r-0 cPMqMQ"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="z" data-slate-length="0">﻿</span></span></span></a><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Join a team of kind, curious, and empathetic individuals</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Radish Lab is a creative agency that believes that good design can help solve big challenges. We partner with organizations that are looking to create greater impact in their work and the world around them.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We believe good design is clear, simple, and engaging. And we believe that good design has the power to move you.We focus on helping social change projects and organizations tell compelling digital stories, deeply engage their audiences, and apply smart creative and technical solutions to some pretty impressive challenges.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">With offices in Brooklyn and Berlin, we love helping our clients create and tell compelling visual stories. </span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Radish Lab is also a certified B Corporation, which means we’re held accountable for meeting the highest standards of overall social and environmental performance, transparency and accountability.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="n" data-slate-length="0">﻿<br/></span></span></span></p></div></div></article></div></div></div></div></div></div></section></div><div data-scroll-point="section-gallery-6808b50d"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-6808b50d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 dLnXab"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 jEioAK"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 ipivQc"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">SELECTED CLIENTS</span></span></span></p><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We partner with organizations, activists and optimists. Here’s a handful we’ve already helped.</span></span></span></h3></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 ebMZHP"><div width="12" class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-1 iozrWS"><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilg/KFkAhPsAE6m7.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilk/lVkUsYEyvKky.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilo/S5EkxjRNYf4U.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ils/UcXAqrsyzCFC.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div></div></div><div width="12" class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-1 iozrWS"><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilw/5vZK251ADpLK.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il0/mJUUpYFqt7ny.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il4/J3g5SeRl41JZ.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il8/pXhL2Ip7Ng1z.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div></div></div></div><div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-map-cb09dc8f"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-cb09dc8f" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 kdUgoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 bEnYHY"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 ipivQc"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">OUR OFFICE</span></span></span></p><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Brooklyn – DUMBO</span></span></span></h3></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 hohQBp"><div class="sc-1dj1hqi-2 dvhjIe"><div style="width:100%;min-height:400px;position:relative"></div></div></div></div></div></div></div></div></div></div></section></div><div class="sc-ax9y9i-0 jbcdEK"></div></main><div data-cy="brand-wrapper-section" class="sc-1ktojtq-0 beiMHd"><a href="https://recruitee.com" target="_blank" rel="noreferrer noopenner" aria-label="Hiring with Recruitee" class="sc-1ktojtq-1 eovEqQ"><svg width="241" height="24" viewBox="0 0 241 24" fill="none"><path fill-rule="evenodd" clip-rule="evenodd" d="M121.51 9.08403C121.485 9.08403 121.46 9.08469 121.435 9.08493C119.658 3.80365 114.669 0 108.792 0C102.914 0 97.9245 3.80438 96.1478 9.08648C91.9409 9.19007 88.5625 12.6349 88.5625 16.8693C88.5625 19.0446 89.4544 21.0112 90.8919 22.4237C91.0503 22.5794 91.3 22.5947 91.475 22.4578C91.6655 22.309 91.8748 22.1555 92.1031 22.0014C92.8412 21.4518 93.8535 20.9681 94.7804 20.6317C94.9048 20.5882 95.4997 20.264 95.1679 19.3905C94.3151 18.5164 93.6697 17.1028 93.6697 15.7125C93.6697 13.5824 95.0765 12.4652 96.7245 12.4652C98.3699 12.4652 99.7851 13.5824 99.7851 15.7125C99.7851 17.0983 99.1371 18.5061 98.2862 19.3801H98.2914C97.9674 20.3704 98.4891 20.6063 98.5701 20.6317C98.857 20.727 99.1495 20.8358 99.4388 20.9557C99.5856 21.0166 99.6222 21.2094 99.5079 21.3197C98.7283 22.0729 98.2735 23.0327 98.0347 23.7028C97.9565 23.9223 98.227 24.0979 98.3967 23.9383C98.9716 23.3983 99.7391 22.7543 100.705 22.1024C101.974 21.1571 103.715 20.3252 105.31 19.7465C105.524 19.6718 106.547 19.1141 105.976 17.6118C104.509 16.1084 103.399 13.6771 103.399 11.2858C103.399 7.62214 105.819 5.70046 108.653 5.70046C111.483 5.70046 113.918 7.62214 113.918 11.2858C113.918 13.6692 112.803 16.0906 111.34 17.5939H111.348C110.791 19.297 111.688 19.703 111.828 19.7465C113.453 20.2863 115.183 21.0737 116.465 21.986C117.538 22.6469 118.404 23.3224 119.071 23.9113C119.243 24.0636 119.504 23.8864 119.427 23.6697C119.19 23.0021 118.723 22.0192 117.921 21.2592C117.805 21.1494 117.841 20.9569 117.988 20.8938C118.234 20.7878 118.481 20.6904 118.722 20.6028C118.847 20.5592 119.444 20.2339 119.111 19.3576C118.255 18.4806 117.608 17.0623 117.608 15.6675C117.608 13.5303 119.019 12.4092 120.672 12.4092C122.323 12.4092 123.743 13.5303 123.743 15.6675C123.743 17.0577 123.093 18.4701 122.239 19.3471H122.245C121.92 20.3406 122.443 20.5774 122.524 20.6028C123.884 21.0545 125.37 21.8032 126.029 22.6379C126.187 22.8377 126.481 22.8633 126.671 22.6944C128.277 21.2682 129.29 19.1872 129.29 16.8693C129.29 12.5696 125.807 9.08403 121.51 9.08403Z" fill="#1999E3"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M144.982 8.29481C144.982 9.17907 144.835 9.97335 144.532 10.653C143.959 10.5875 143.321 10.5383 142.928 10.5383C142.331 10.5383 141.504 10.653 140.973 10.8987C140.351 11.1853 139.941 11.7339 139.941 12.8803V21.1096C139.18 21.4782 138.297 21.6255 137.29 21.6255V11.693C137.29 10.1126 137.904 9.29375 139.303 8.72875C140.4 8.28657 141.799 8.0573 142.896 8.0573C143.55 8.0573 144.336 8.13913 144.982 8.29481Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M154.786 13.7155C155.654 13.7155 155.891 13.3388 155.891 12.7738C155.891 11.2917 154.287 10.3746 152.519 10.3746C150.49 10.3746 148.894 11.5784 148.501 13.7155H154.786ZM152.912 21.6255C148.493 21.6255 145.793 18.8742 145.793 14.8456C145.793 10.8414 148.452 8.05731 152.536 8.05731C155.997 8.05731 158.477 10.0553 158.477 13.3142C158.477 15.2386 157.609 15.8117 155.572 15.8117H148.485C148.87 17.9981 150.547 19.2099 153.019 19.2099C154.238 19.2099 155.523 18.9152 156.415 18.6204C156.734 19.2837 156.865 20.0616 156.865 20.9295C155.76 21.3225 154.377 21.6255 152.912 21.6255Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M160.187 14.8456C160.187 10.8496 162.904 8.05731 167.306 8.05731C168.755 8.05731 170.121 8.36027 171.169 8.72876C171.169 9.59672 171.038 10.3582 170.727 11.0133C169.876 10.7186 168.583 10.4565 167.478 10.4565C164.622 10.4565 162.846 12.1924 162.846 14.8456C162.846 17.4985 164.63 19.1772 167.429 19.1772C168.624 19.1772 169.917 18.8742 170.809 18.5713C171.112 19.2509 171.259 20.0452 171.259 20.9295C170.154 21.3225 168.771 21.6255 167.315 21.6255C162.904 21.6255 160.187 18.8415 160.187 14.8456Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M181.578 8.29482C181.578 9.17908 181.431 9.97336 181.128 10.653C180.555 10.5875 179.917 10.5384 179.524 10.5384C178.927 10.5384 178.1 10.653 177.568 10.8987C176.947 11.1853 176.537 11.7339 176.537 12.8803V21.1096C175.776 21.4782 174.892 21.6255 173.885 21.6255V11.693C173.885 10.1126 174.5 9.29376 175.899 8.72876C176.995 8.28659 178.395 8.05731 179.491 8.05731C180.146 8.05731 180.931 8.13914 181.578 8.29482Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M186.112 15.5825C186.112 17.6377 187.225 19.1854 189.336 19.1854C189.68 19.1854 190.539 19.1444 191.243 18.8579C191.987 18.5548 192.249 18.0799 192.249 17.3675V8.57317C193.01 8.20468 193.894 8.05731 194.9 8.05731V17.9899C194.9 19.5702 194.262 20.4137 192.887 20.9541C191.807 21.3799 190.236 21.6255 189.099 21.6255C185.629 21.6255 183.461 19.341 183.461 15.7954V8.57317C184.221 8.20468 185.105 8.05731 186.112 8.05731V15.5825Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M201.104 21.1096C200.342 21.4782 199.458 21.6255 198.452 21.6255V8.57314C199.213 8.20465 200.097 8.05729 201.104 8.05729V21.1096ZM201.529 4.11866C201.529 5.08492 200.752 5.86282 199.786 5.86282C198.821 5.86282 198.043 5.08492 198.043 4.11866C198.043 3.15241 198.821 2.37451 199.786 2.37451C200.752 2.37451 201.529 3.15241 201.529 4.11866Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M208.288 10.7267V17.0073C208.288 18.866 209.532 19.1772 211.815 19.1772C211.815 20.0697 211.684 20.8558 211.357 21.5273C211.005 21.6009 210.768 21.6255 210.391 21.6255C209.008 21.6255 206.913 21.298 206.063 19.4392C205.677 18.604 205.637 17.6459 205.637 16.6142V10.7267H203.288C203.288 9.80145 203.419 8.99894 203.754 8.30296H205.637V4.60176C206.397 4.23327 207.281 4.08591 208.288 4.08591V8.30296H211.897C211.897 9.22007 211.758 10.0306 211.422 10.7267H208.288Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M222.347 13.7155C223.215 13.7155 223.453 13.3388 223.453 12.7738C223.453 11.2917 221.849 10.3746 220.081 10.3746C218.051 10.3746 216.456 11.5784 216.063 13.7155H222.347ZM220.474 21.6255C216.055 21.6255 213.355 18.8742 213.355 14.8456C213.355 10.8414 216.014 8.05731 220.097 8.05731C223.558 8.05731 226.038 10.0553 226.038 13.3142C226.038 15.2386 225.17 15.8117 223.133 15.8117H216.047C216.431 17.9981 218.108 19.2099 220.58 19.2099C221.799 19.2099 223.084 18.9152 223.976 18.6204C224.295 19.2837 224.426 20.0616 224.426 20.9295C223.321 21.3225 221.938 21.6255 220.474 21.6255Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M236.75 13.7155C237.618 13.7155 237.855 13.3388 237.855 12.7738C237.855 11.2917 236.251 10.3746 234.483 10.3746C232.454 10.3746 230.858 11.5784 230.465 13.7155H236.75ZM234.876 21.6255C230.457 21.6255 227.757 18.8742 227.757 14.8456C227.757 10.8414 230.416 8.05731 234.499 8.05731C237.961 8.05731 240.441 10.0553 240.441 13.3142C240.441 15.2386 239.573 15.8117 237.535 15.8117H230.449C230.833 17.9981 232.511 19.2099 234.982 19.2099C236.202 19.2099 237.486 18.9152 238.378 18.6204C238.698 19.2837 238.829 20.0616 238.829 20.9295C237.723 21.3225 236.341 21.6255 234.876 21.6255Z" fill="#37474F"></path><path d="M9 20V8.72656H7.59375V13.6016H1.40625V8.72656H0V20H1.40625V14.8672H7.59375V20H9Z" fill="#37474F"></path><path d="M12.4062 9.95312C12.9219 9.95312 13.3438 9.53125 13.3438 9.01562C13.3438 8.5 12.9219 8.07812 12.4062 8.07812C11.8906 8.07812 11.4688 8.5 11.4688 9.01562C11.4688 9.53125 11.8906 9.95312 12.4062 9.95312ZM11.7344 20H13.0781V11.5781H11.7344V20Z" fill="#37474F"></path><path d="M15.6406 20H16.9844V14.7812C16.9844 13.5938 17.9141 12.7344 19.1953 12.7344C19.4609 12.7344 19.9453 12.7812 20.0547 12.8125V11.4688C19.8828 11.4453 19.6016 11.4297 19.3828 11.4297C18.2656 11.4297 17.2969 12.0078 17.0469 12.8281H16.9219V11.5781H15.6406V20Z" fill="#37474F"></path><path d="M22.4375 9.95312C22.9531 9.95312 23.375 9.53125 23.375 9.01562C23.375 8.5 22.9531 8.07812 22.4375 8.07812C21.9219 8.07812 21.5 8.5 21.5 9.01562C21.5 9.53125 21.9219 9.95312 22.4375 9.95312ZM21.7656 20H23.1094V11.5781H21.7656V20Z" fill="#37474F"></path><path d="M25.6719 20H27.0156V15.0156C27.0156 13.5391 27.8828 12.6406 29.2266 12.6406C30.5703 12.6406 31.2109 13.3594 31.2109 14.875V20H32.5547V14.5469C32.5547 12.5469 31.5 11.4297 29.6094 11.4297C28.3203 11.4297 27.5 11.9766 27.0781 12.9062H26.9531V11.5781H25.6719V20Z" fill="#37474F"></path><path d="M38.4844 23.2344C40.7812 23.2344 42.2344 22.0312 42.2344 20.1484V11.5781H40.9531V12.9141H40.8281C40.3438 12.0078 39.3047 11.4297 38.125 11.4297C35.9609 11.4297 34.5938 13.1406 34.5938 15.6641C34.5938 18.1875 35.9453 19.875 38.125 19.875C39.2812 19.875 40.2344 19.3516 40.7656 18.4219H40.8906V20.0781C40.8906 21.3203 39.9922 22.0625 38.4844 22.0625C37.2734 22.0625 36.5234 21.6172 36.375 20.9297H34.9531C35.1562 22.3203 36.4531 23.2344 38.4844 23.2344ZM38.4219 18.6875C36.8594 18.6875 35.9844 17.5 35.9844 15.6641C35.9844 13.8281 36.8594 12.6406 38.4219 12.6406C39.9766 12.6406 40.9219 13.8281 40.9219 15.6641C40.9219 17.5 39.9844 18.6875 38.4219 18.6875Z" fill="#37474F"></path><path d="M59.875 11.5781H58.5234L56.8672 18.3125H56.7422L54.8594 11.5781H53.5703L51.6875 18.3125H51.5625L49.9062 11.5781H48.5469L50.9062 20H52.2656L54.1406 13.4844H54.2656L56.1484 20H57.5156L59.875 11.5781Z" fill="#37474F"></path><path d="M62.375 9.95312C62.8906 9.95312 63.3125 9.53125 63.3125 9.01562C63.3125 8.5 62.8906 8.07812 62.375 8.07812C61.8594 8.07812 61.4375 8.5 61.4375 9.01562C61.4375 9.53125 61.8594 9.95312 62.375 9.95312ZM61.7031 20H63.0469V11.5781H61.7031V20Z" fill="#37474F"></path><path d="M66.1719 9.39844V11.5781H64.8125V12.7031H66.1719V17.8125C66.1719 19.4219 66.8672 20.0625 68.6016 20.0625C68.8672 20.0625 69.125 20.0312 69.3906 19.9844V18.8516C69.1406 18.875 69.0078 18.8828 68.7656 18.8828C67.8906 18.8828 67.5156 18.4609 67.5156 17.4688V12.7031H69.3906V11.5781H67.5156V9.39844H66.1719Z" fill="#37474F"></path><path d="M71.5 20H72.8438V15.0156C72.8438 13.5938 73.6719 12.6406 75.1797 12.6406C76.4531 12.6406 77.125 13.3828 77.125 14.875V20H78.4688V14.5469C78.4688 12.5703 77.3438 11.4297 75.5625 11.4297C74.2734 11.4297 73.3906 11.9766 72.9688 12.9062H72.8438V8.23438H71.5V20Z" fill="#37474F"></path></svg></a></div></div></div>


<script id="__LOADABLE_REQUIRED_CHUNKS__" type="application/json">[]</script><script id="__LOADABLE_REQUIRED_CHUNKS___ext" type="application/json">{"namedChunks":[]}</script>
<script async data-chunk="main" src="/js/PublicApp/web/main-bundle-669e9f11.js"></script>


  </body>
</html>

-  recorded_at: Thu, 27 Jun 2024 13:37:19 GMT
+        <!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>




      <meta content="Careers homepage" name="description"/>

      <meta content="Careers homepage" property="og:description"/>
      <meta content="https://radishlab.recruitee.com/" property="og:url"/>
      <meta content="Radish Lab" property="og:site_name"/>

      <meta content="website" property="og:type"/>

      <meta content="https://careers.recruiteecdn.com/image/upload/q_auto,w_1920,c_limit/production/images/AQJm/eTpqtQ6sZ9sc.jpeg" property="og:image"/>
      <meta content="800" property="og:image:width"/>
      <meta content="418" property="og:image:height"/>


<style data-styled="true" data-styled-version="5.1.1">.eFVUhY{font-size:32px;line-height:1.2em;color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:600;font-style:normal;text-transform:none;text-wrap:balance;margin-top:0px;margin-bottom:0px;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;word-break:normal;overflow-wrap:break-word;margin-top:28px;margin-bottom:28px;}/*!sc*/
@media only screen and (min-width:768px){.eFVUhY{font-size:48px;}}/*!sc*/
data-styled.g4[id="sc-1npqnwg-3"]{content:"eFVUhY,"}/*!sc*/
.fXpJdS{font-size:24px;line-height:1.2em;color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:600;font-style:normal;text-transform:none;text-wrap:balance;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;word-break:normal;overflow-wrap:break-word;margin-top:0px;margin-bottom:0px;margin-top:28px;margin-bottom:28px;}/*!sc*/
@media only screen and (min-width:768px){.fXpJdS{font-size:32px;}}/*!sc*/
data-styled.g6[id="sc-1npqnwg-5"]{content:"fXpJdS,"}/*!sc*/
.iPueVD{font-size:16px;line-height:1.6em;color:#000000;font-weight:400;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;margin-top:0px;margin-bottom:0px;margin-top:20px;margin-bottom:20px;}/*!sc*/
@media only screen and (min-width:768px){.iPueVD{font-size:20px;}}/*!sc*/
data-styled.g11[id="sc-1npqnwg-10"]{content:"iPueVD,"}/*!sc*/
.eDCgIN{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;}/*!sc*/
.eDCgIN::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.eDCgIN{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.eDCgIN{line-height:1.6em;}}/*!sc*/
.jmbcoz{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;font-size:16px;line-height:1.5em;}/*!sc*/
.jmbcoz::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{line-height:1.6em;}}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{font-size:16px;}}/*!sc*/
.xZUGZ{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;border:1px solid #000000;background-color:#000000;color:#ffffff;}/*!sc*/
.xZUGZ::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.xZUGZ{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.xZUGZ{line-height:1.6em;}}/*!sc*/
.xZUGZ:hover{border:1px solid #000;background-color:#000;color:#ffffff;}/*!sc*/
data-styled.g13[id="sc-s03za1-0"]{content:"eDCgIN,jmbcoz,xZUGZ,"}/*!sc*/
.bIScAX{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-self:center;-ms-flex-item-align:center;align-self:center;color:currentColor;pointer-events:none;}/*!sc*/
data-styled.g21[id="sc-1rd450u-0"]{content:"bIScAX,"}/*!sc*/
.cPMqMQ{font-size:inherit;color:#000000;}/*!sc*/
data-styled.g43[id="sc-5egf6r-0"]{content:"cPMqMQ,"}/*!sc*/
.cKZGOF{line-height:1.5em;}/*!sc*/
.cKZGOF .sc-1tu8yb8-0{display:none;}/*!sc*/
.cKZGOF > :first-child{margin-top:0 !important;}/*!sc*/
.cKZGOF > :last-child{margin-bottom:0 !important;}/*!sc*/
data-styled.g45[id="sc-1tu8yb8-1"]{content:"cKZGOF,"}/*!sc*/
.gXycJU{width:16px;min-width:16px;}/*!sc*/
data-styled.g71[id="sc-1jf9qcy-0"]{content:"gXycJU,"}/*!sc*/
.beiMHd{display:none;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding:32px 0px;font-size:18px;line-height:normal;border-top:1px solid rgba(0,0,0,0.25);background-color:#fff;}/*!sc*/
data-styled.g89[id="sc-1ktojtq-0"]{content:"beiMHd,"}/*!sc*/
.eovEqQ{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
data-styled.g90[id="sc-1ktojtq-1"]{content:"eovEqQ,"}/*!sc*/
.gJxpwG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;min-height:66vh;}/*!sc*/
.gQRcOO{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;min-height:33vh;}/*!sc*/
.kmsnUh{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;}/*!sc*/
data-styled.g91[id="sc-gfrfnr-0"]{content:"gJxpwG,gQRcOO,kmsnUh,"}/*!sc*/
.iVfIXi{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;background-repeat:no-repeat;background-position:center center;background-size:cover;z-index:1;}/*!sc*/
data-styled.g92[id="sc-gfrfnr-1"]{content:"iVfIXi,"}/*!sc*/
.deOrHQ{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;isolation:isolate;}/*!sc*/
data-styled.g93[id="sc-gfrfnr-2"]{content:"deOrHQ,"}/*!sc*/
@media only screen{.ixGbOy{display:block;}}/*!sc*/
@media only screen and (min-width:768px){.ixGbOy{display:block;}}/*!sc*/
data-styled.g94[id="sc-1oxti4r-0"]{content:"ixGbOy,"}/*!sc*/
.UZqcu{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;width:100%;height:100%;object-position:center center;object-fit:cover;z-index:0;}/*!sc*/
data-styled.g97[id="sc-itprxg-0"]{content:"UZqcu,"}/*!sc*/
.ebVyJP{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;position:relative;}/*!sc*/
data-styled.g101[id="sc-18h7are-0"]{content:"ebVyJP,"}/*!sc*/
.guycoN{width:100%;padding-top:48px;padding-bottom:48px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:992px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:1200px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:1600px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
.gZDsxt{width:100%;padding-top:20px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
.kdUgoN{width:100%;padding-top:32px;padding-bottom:32px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:992px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:1200px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:1600px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
.hacApq{width:100%;padding-top:32px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
.dLnXab{width:100%;padding-top:48px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
data-styled.g106[id="sc-1tu9fip-1"]{content:"guycoN,gZDsxt,kdUgoN,hacApq,dLnXab,"}/*!sc*/
.gJVWbp{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
.bSaXtg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;}/*!sc*/
data-styled.g107[id="sc-1tu9fip-2"]{content:"gJVWbp,bSaXtg,"}/*!sc*/
.jIYAZB{margin:0 auto;width:100%;max-width:calc(100% - 48px);}/*!sc*/
@media only screen and (min-width:768px){.jIYAZB{max-width:704px;}}/*!sc*/
@media only screen and (min-width:992px){.jIYAZB{max-width:920px;}}/*!sc*/
@media only screen and (min-width:1200px){.jIYAZB{max-width:1152px;}}/*!sc*/
data-styled.g109[id="sc-ji5wy4-0"]{content:"jIYAZB,"}/*!sc*/
.dbJNvX{margin:0 auto;width:100%;max-width:calc(100% - 48px);}/*!sc*/
@media only screen and (min-width:768px){.dbJNvX{max-width:704px;}}/*!sc*/
@media only screen and (min-width:992px){.dbJNvX{max-width:920px;}}/*!sc*/
@media only screen and (min-width:1200px){.dbJNvX{max-width:1152px;}}/*!sc*/
data-styled.g125[id="sc-1dj1hqi-0"]{content:"dbJNvX,"}/*!sc*/
.dDTKOA{--gap:0px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.bEnYHY{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.jEioAK{--gap:24px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.ebMZHP{--gap:16px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.iozrWS{--gap:16px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;}/*!sc*/
.hohQBp{--gap:0px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;}/*!sc*/
data-styled.g126[id="sc-1dj1hqi-1"]{content:"dDTKOA,bEnYHY,jEioAK,ebMZHP,iozrWS,hohQBp,"}/*!sc*/
.dvhjIe{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.dvhjIe{width:100%;}}/*!sc*/
.hPupHS{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.hPupHS{width:calc( 50% - var(--gap) + ((var(--gap) / var(--columns)) * 6) );}}/*!sc*/
.fXdQP{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.fXdQP{width:calc( 50% - var(--gap) + ((var(--gap) / var(--columns)) * 6) );}}/*!sc*/
.lbZeFW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:calc( 25% - var(--gap) + ((var(--gap) / var(--columns)) * 3) );}/*!sc*/
@media only screen and (min-width:768px){.lbZeFW{width:calc( 25% - var(--gap) + ((var(--gap) / var(--columns)) * 3) );}}/*!sc*/
data-styled.g127[id="sc-1dj1hqi-2"]{content:"dvhjIe,hPupHS,fXdQP,lbZeFW,"}/*!sc*/
.jLGbJs{-webkit-transition:background-color 0.14s ease-in-out,color 0.14s ease-in-out;transition:background-color 0.14s ease-in-out,color 0.14s ease-in-out;}/*!sc*/
data-styled.g128[id="sc-3k6t01-0"]{content:"jLGbJs,"}/*!sc*/
.kJLltb{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;max-width:calc(100% - 48px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-flex:1;-ms-flex:1;flex:1;}/*!sc*/
data-styled.g130[id="sc-1aabq8s-1"]{content:"kJLltb,"}/*!sc*/
.kcKagb{margin-left:14px;margin-right:-2px;}/*!sc*/
data-styled.g133[id="sc-1aabq8s-4"]{content:"kcKagb,"}/*!sc*/
.QEQag{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding-left:8px;padding-right:8px;-webkit-text-decoration:none;text-decoration:none;overflow:hidden;opacity:1;-webkit-transition:opacity 0.14s ease-in-out;transition:opacity 0.14s ease-in-out;height:80px;margin:-20px 0;color:#fff;color:inherit;}/*!sc*/
data-styled.g142[id="sc-pxbyo9-0"]{content:"QEQag,"}/*!sc*/
.klfKrz{display:block;width:auto;max-width:200px;max-height:55%;justify-self:start;margin-right:0;}/*!sc*/
@media only screen and (min-width:768px){.klfKrz{width:auto;}}/*!sc*/
data-styled.g143[id="sc-83wl6d-0"]{content:"klfKrz,"}/*!sc*/
.eNDDPg{white-space:nowrap;font-weight:600;font-size:16px;text-overflow:ellipsis;overflow:hidden;display:none;}/*!sc*/
@media only screen and (min-width:768px){.eNDDPg{overflow:initial;text-overflow:unset;font-size:22px;}}/*!sc*/
data-styled.g144[id="sc-83wl6d-1"]{content:"eNDDPg,"}/*!sc*/
.dPcHAE{display:inline-block;padding:8px 12px;font-size:16px;line-height:24px;text-align:center;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;margin:0 2px;color:#fff;font-weight:600;font-style:normal;text-transform:none;}/*!sc*/
.dPcHAE:hover,.dPcHAE:focus{background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g145[id="sc-ir8rf5-0"]{content:"dPcHAE,"}/*!sc*/
.hLPFpI{width:100%;border-radius:4px;overflow-x:hidden;overflow-y:auto;text-align:center;box-shadow:0 2px 8px rgba(0,0,0,0.12);padding:8px 4px;}/*!sc*/
body.is-keyboard-focused .hLPFpI [role='menuitem'][data-selected]{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
body.is-keyboard-focused .hLPFpI [role='menuitem']{-webkit-transition:undefined;transition:undefined;}/*!sc*/
@media only screen and (min-width:768px){.hLPFpI{width:auto;}}/*!sc*/
data-styled.g156[id="sc-1tu9xny-0"]{content:"hLPFpI,"}/*!sc*/
.kZTElj{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:58px;width:100%;text-align:center;padding:12px 16px;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;color:#000000;}/*!sc*/
.kZTElj[data-selected]{color:#000000;background-color:rgba(0,0,0,0.05);}/*!sc*/
data-styled.g157[id="sc-1tu9xny-1"]{content:"kZTElj,"}/*!sc*/
.iPvmIC{margin:1px 0;font-size:16px;line-height:22px;border-color:#fff;color:#fff;font-weight:600;font-style:normal;text-transform:none;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:40px;min-width:40px;margin:0px;}/*!sc*/
@media only screen and (min-width:768px){.iPvmIC{line-height:22px;}}/*!sc*/
.iPvmIC[data-selected],.iPvmIC:hover,.iPvmIC:focus{color:rgba(255,255,255,0.9);background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g158[id="sc-1tu9xny-2"]{content:"iPvmIC,"}/*!sc*/
.cAzrSG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:40px;min-width:40px;margin:0px;}/*!sc*/
data-styled.g159[id="sc-1tu9xny-3"]{content:"cAzrSG,"}/*!sc*/
.hlNgLl{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding:8px;margin:0 2px;text-align:center;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;width:40px;height:40px;color:#fff;}/*!sc*/
.hlNgLl:hover{background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g167[id="sc-7glywv-0"]{content:"hlNgLl,"}/*!sc*/
.hdTF{list-style:none;padding-left:0;margin-top:0;margin-bottom:0;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;row-gap:8px;-webkit-box-pack:end;-webkit-justify-content:flex-end;-ms-flex-pack:end;justify-content:flex-end;}/*!sc*/
data-styled.g168[id="sc-1xewqye-0"]{content:"hdTF,"}/*!sc*/
@media only screen and (min-width:768px){.iudIDi{position:relative;}}/*!sc*/
data-styled.g174[id="sc-1tx5im8-0"]{content:"iudIDi,"}/*!sc*/
.hBOHsL{position:absolute;width:calc(100% - 48px);margin-left:24px;margin-right:24px;top:calc( 100% - 10px );left:0;z-index:1;}/*!sc*/
@media only screen and (min-width:768px){.hBOHsL{top:calc(100% + 10px);right:0;left:auto;width:-webkit-max-content;width:-moz-max-content;width:max-content;min-width:312px;margin-left:0;margin-right:0;}}/*!sc*/
.hBOHsL div[role='menu']{overscroll-behavior:contain;max-height:calc( 100vh - px - 12px );max-height:calc( 100dvh - px - 12px );}/*!sc*/
data-styled.g175[id="sc-1tx5im8-1"]{content:"hBOHsL,"}/*!sc*/
.cghDST{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;max-width:calc(100% - 48px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-flex:1;-ms-flex:1;flex:1;}/*!sc*/
@media only screen and (min-width:768px){.cghDST{max-width:100%;-webkit-box-flex:unset;-webkit-flex-grow:unset;-ms-flex-positive:unset;flex-grow:unset;}}/*!sc*/
data-styled.g176[id="sc-1hkznj2-0"]{content:"cghDST,"}/*!sc*/
.guEbMs{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}/*!sc*/
data-styled.g177[id="sc-1hkznj2-1"]{content:"guEbMs,"}/*!sc*/
.dYPHZW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;width:100%;display:none;}/*!sc*/
@media only screen and (min-width:768px){.dYPHZW{width:100%;}}/*!sc*/
@media only screen and (min-width:992px){.dYPHZW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}}/*!sc*/
data-styled.g187[id="sc-it5itd-0"]{content:"dYPHZW,"}/*!sc*/
.ciZwhu{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media only screen and (min-width:768px){.ciZwhu{width:100%;}}/*!sc*/
@media only screen and (min-width:992px){.ciZwhu{display:none;}}/*!sc*/
data-styled.g188[id="sc-it5itd-1"]{content:"ciZwhu,"}/*!sc*/
.kllnfT{position:relative;}/*!sc*/
data-styled.g191[id="sc-z9o81a-0"]{content:"kllnfT,"}/*!sc*/
.fsBFXt{position:absolute;top:0;left:0;width:100%;z-index:2001;}/*!sc*/
data-styled.g192[id="sc-z9o81a-1"]{content:"fsBFXt,"}/*!sc*/
.hfKXfE{visibility:hidden;width:100%;pointer-events:none;}/*!sc*/
data-styled.g193[id="sc-lqj8ks-0"]{content:"hfKXfE,"}/*!sc*/
.bKUtEV{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;height:100%;width:100%;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;}/*!sc*/
.hYJywo{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;height:100%;width:100%;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
data-styled.g196[id="sc-pelm1o-0"]{content:"bKUtEV,hYJywo,"}/*!sc*/
.cOPlFo{width:100%;text-align:left;}/*!sc*/
.ipivQc{width:100%;text-align:center;}/*!sc*/
data-styled.g197[id="sc-pelm1o-1"]{content:"cOPlFo,ipivQc,"}/*!sc*/
.hmrXLz{width:100%;}/*!sc*/
data-styled.g198[id="sc-pelm1o-2"]{content:"hmrXLz,"}/*!sc*/
.iOQKaL{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
@media only screen and (min-width:768px){.iOQKaL{-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;}}/*!sc*/
.OebVS{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
@media only screen and (min-width:768px){.OebVS{-webkit-flex-direction:row-reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse;}}/*!sc*/
data-styled.g199[id="sc-bq9z91-0"]{content:"iOQKaL,OebVS,"}/*!sc*/
.eDtYEt{z-index:1;}/*!sc*/
data-styled.g235[id="sc-1l3pw7p-0"]{content:"eDtYEt,"}/*!sc*/
.homvAg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
data-styled.g356[id="sc-73r8cv-0"]{content:"homvAg,"}/*!sc*/
.ilRiFP{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;width:100%;background-color:#fff;min-height:inherit;}/*!sc*/
data-styled.g357[id="sc-73r8cv-1"]{content:"ilRiFP,"}/*!sc*/
.fDyLzp{position:relative;overflow:hidden;width:100%;}/*!sc*/
.fDyLzp::before{content:'';display:block;padding-bottom:100.00%;}/*!sc*/
data-styled.g369[id="sc-dkkku4-0"]{content:"fDyLzp,"}/*!sc*/
.dHdKMs{position:absolute;top:0;left:0;right:0;bottom:0;}/*!sc*/
data-styled.g370[id="sc-dkkku4-1"]{content:"dHdKMs,"}/*!sc*/
.cTyKMn{max-width:100%;width:100%;height:auto;}/*!sc*/
.ftWfoy{max-width:100%;width:100%;height:auto;object-fit:cover;height:100%;}/*!sc*/
data-styled.g373[id="sc-146moy0-0"]{content:"cTyKMn,ftWfoy,"}/*!sc*/
.lcroFG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;width:100%;height:auto;position:relative;}/*!sc*/
data-styled.g390[id="sc-11gkm9w-0"]{content:"lcroFG,"}/*!sc*/
.YAzbZ{width:100%;height:auto;}/*!sc*/
data-styled.g391[id="sc-11gkm9w-1"]{content:"YAzbZ,"}/*!sc*/
.bpnyeu{position:relative;width:100%;height:100%;display:block;}/*!sc*/
data-styled.g434[id="sc-fw9s8b-0"]{content:"bpnyeu,"}/*!sc*/
.bJoAoi{font-size:16px;line-height:1.6em;color:#000000;font-weight:400;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;min-width:100%;color:#000000;border-collapse:collapse;}/*!sc*/
@media only screen and (min-width:768px){.bJoAoi{font-size:20px;}}/*!sc*/
.bJoAoi thead tr,.bJoAoi tbody tr:not(:last-of-type){border-bottom:1px solid rgba(0,0,0,0.25);}/*!sc*/
.bJoAoi th{color:rgba(0,0,0,0.8);font-weight:inherit;}/*!sc*/
.bJoAoi th,.bJoAoi td{height:64px;text-align:left;padding:8px;}/*!sc*/
.bJoAoi th:first-of-type,.bJoAoi td:first-of-type{padding-left:0;}/*!sc*/
.bJoAoi th:last-of-type,.bJoAoi td:last-of-type{padding-right:0;}/*!sc*/
.bJoAoi td{height:80px;}/*!sc*/
data-styled.g472[id="sc-18rtkup-0"]{content:"bJoAoi,"}/*!sc*/
.hhapWv{max-width:100%;overflow-x:auto;padding:0 4px;}/*!sc*/
data-styled.g473[id="sc-18rtkup-1"]{content:"hhapWv,"}/*!sc*/
.bqJcqI{color:#000000;font-weight:400;font-style:normal;text-transform:none;-webkit-text-decoration:none;text-decoration:none;word-break:break-word;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;}/*!sc*/
.bqJcqI:hover{color:#000;}/*!sc*/
data-styled.g474[id="sc-18rtkup-2"]{content:"bqJcqI,"}/*!sc*/
.ffHrMJ{margin:0 -4px;}/*!sc*/
data-styled.g475[id="sc-1qe5ahw-0"]{content:"ffHrMJ,"}/*!sc*/
.brHqfD{font-size:16px;line-height:24px;}/*!sc*/
data-styled.g476[id="sc-465zle-0"]{content:"brHqfD,"}/*!sc*/
.fTGeMR{margin-top:20px;padding-bottom:20px;border-bottom:1px solid rgba(0,0,0,0.25);}/*!sc*/
data-styled.g477[id="sc-465zle-1"]{content:"fTGeMR,"}/*!sc*/
.bCpqiX{font-weight:500;color:#000000;-webkit-text-decoration:none;text-decoration:none;word-break:break-word;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;}/*!sc*/
.bCpqiX:hover{color:#000;}/*!sc*/
data-styled.g478[id="sc-465zle-2"]{content:"bCpqiX,"}/*!sc*/
.gkgGSG{position:relative;margin-top:8px;color:#000000;}/*!sc*/
data-styled.g479[id="sc-465zle-3"]{content:"gkgGSG,"}/*!sc*/
.jvvolj{width:20px;height:20px;display:inline-block;margin-right:8px;}/*!sc*/
.jvvolj > *{position:absolute;top:4px;left:0px;}/*!sc*/
data-styled.g480[id="sc-465zle-4"]{content:"jvvolj,"}/*!sc*/
.WxTrG{margin-top:12px;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;-webkit-align-items:end;-webkit-box-align:end;-ms-flex-align:end;align-items:end;gap:40px;}/*!sc*/
data-styled.g481[id="sc-465zle-5"]{content:"WxTrG,"}/*!sc*/
.exQcZ{display:none;}/*!sc*/
@media only screen and (min-width:768px){.exQcZ{display:block;}}/*!sc*/
data-styled.g482[id="sc-1dywz0m-0"]{content:"exQcZ,"}/*!sc*/
.gcbsVn{display:block;}/*!sc*/
@media only screen and (min-width:768px){.gcbsVn{display:none;}}/*!sc*/
data-styled.g483[id="sc-1dywz0m-1"]{content:"gcbsVn,"}/*!sc*/
.dWcJRW{display:block;}/*!sc*/
@media only screen and (min-width:768px){.dWcJRW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}}/*!sc*/
data-styled.g490[id="sc-1mxcttb-0"]{content:"dWcJRW,"}/*!sc*/
.dPfocN{width:100%;}/*!sc*/
data-styled.g493[id="sc-4j8eof-0"]{content:"dPfocN,"}/*!sc*/
.jFfmvQ{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
data-styled.g494[id="sc-4j8eof-1"]{content:"jFfmvQ,"}/*!sc*/
.iOxTuT{opacity:1;}/*!sc*/
data-styled.g495[id="sc-4j8eof-2"]{content:"iOxTuT,"}/*!sc*/
.iZuBTr{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;text-align:left;}/*!sc*/
data-styled.g504[id="sc-1we8l0o-0"]{content:"iZuBTr,"}/*!sc*/
.kNKRnF{width:100%;-webkit-transition:width 0.1s linear,padding 0.1s linear;transition:width 0.1s linear,padding 0.1s linear;}/*!sc*/
@media only screen and (min-width:768px){.kNKRnF{width:100%;}}/*!sc*/
data-styled.g505[id="sc-1we8l0o-1"]{content:"kNKRnF,"}/*!sc*/
.gBDROR{position:absolute;top:0px;left:0px;border:0;-webkit-clip:rect(0 0 0 0);clip:rect(0 0 0 0);height:1px;width:1px;margin:-1px;padding:0;overflow:hidden;}/*!sc*/
.gBDROR:focus-within{background-color:#fff;z-index:1000;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:auto;height:auto;margin:0px;padding:6px;-webkit-clip:auto;clip:auto;}/*!sc*/
data-styled.g509[id="sc-q8cmux-0"]{content:"gBDROR,"}/*!sc*/
.kJsRIK{color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.kJsRIK:focus{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
data-styled.g510[id="sc-q8cmux-1"]{content:"kJsRIK,"}/*!sc*/
.jbcdEK{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
data-styled.g511[id="sc-ax9y9i-0"]{content:"jbcdEK,"}/*!sc*/
html{line-height:1.15;-webkit-text-size-adjust:100%;}/*!sc*/
body{margin:0;}/*!sc*/
main{display:block;}/*!sc*/
h1{font-size:2em;margin:0.67em 0;}/*!sc*/
hr{box-sizing:content-box;height:0;overflow:visible;}/*!sc*/
pre{font-family:monospace,monospace;font-size:1em;}/*!sc*/
a{background-color:transparent;}/*!sc*/
abbr[title]{border-bottom:none;-webkit-text-decoration:underline;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;}/*!sc*/
b,strong{font-weight:bolder;}/*!sc*/
code,kbd,samp{font-family:monospace,monospace;font-size:1em;}/*!sc*/
small{font-size:80%;}/*!sc*/
sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline;}/*!sc*/
sub{bottom:-0.25em;}/*!sc*/
sup{top:-0.5em;}/*!sc*/
img{border-style:none;}/*!sc*/
button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0;}/*!sc*/
button,input{overflow:visible;}/*!sc*/
button,select{text-transform:none;}/*!sc*/
button,[type='button'],[type='reset'],[type='submit']{-webkit-appearance:none;}/*!sc*/
button::-moz-focus-inner,[type='button']::-moz-focus-inner,[type='reset']::-moz-focus-inner,[type='submit']::-moz-focus-inner{border-style:none;padding:0;}/*!sc*/
fieldset{padding:0.35em 0.75em 0.625em;}/*!sc*/
legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal;}/*!sc*/
progress{vertical-align:baseline;}/*!sc*/
textarea{overflow:auto;}/*!sc*/
[type='checkbox'],[type='radio']{box-sizing:border-box;padding:0;}/*!sc*/
[type='number']::-webkit-inner-spin-button,[type='number']::-webkit-outer-spin-button{height:auto;}/*!sc*/
[type='search']{-webkit-appearance:textfield;outline-offset:0;}/*!sc*/
[type='search']::-webkit-search-decoration{-webkit-appearance:none;}/*!sc*/
::-webkit-file-upload-button{-webkit-appearance:button;font:inherit;}/*!sc*/
[type='number']::-webkit-inner-spin-button,[type='number']::-webkit-outer-spin-button{-webkit-appearance:none;margin:0;}/*!sc*/
[type='number']{-moz-appearance:textfield;}/*!sc*/
details{display:block;}/*!sc*/
summary{display:list-item;}/*!sc*/
template{display:none;}/*!sc*/
[hidden]{display:none;}/*!sc*/
*{box-sizing:border-box;}/*!sc*/
html{-webkit-overflow-scrolling:touch;-webkit-scroll-behavior:auto;-moz-scroll-behavior:auto;-ms-scroll-behavior:auto;scroll-behavior:auto;}/*!sc*/
body{min-height:100vh;padding:0;margin:0;background-color:#f1f4f7;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',"Roboto",'Helvetica Neue',"Helvetica","Arial",sans-serif;font-size:16px;line-height:1.5;color:#000;font-variant-ligatures:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;-webkit-overflow-scrolling:touch;overscroll-behavior-y:none;}/*!sc*/
h1,h2,h3,h4,h5,h6,blockquote{line-height:1.15;margin:0;}/*!sc*/
*:focus{outline:none;}/*!sc*/
body.is-keyboard-focused *:focus{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
[inert]{pointer-events:none;cursor:default;}/*!sc*/
[inert],[inert] *{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}/*!sc*/
:root{--reach-slider:1;--reach-dialog:1;--reach-tabs:1;--reach-combobox:1;--reach-menu-button:1;--reach-accordion:1;--reach-skip-nav:1;}/*!sc*/
.custom-css-apply-with-custom-integrations{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;gap:16px;margin-top:16px;margin-bottom:16px;}/*!sc*/
.custom-css-apply-with-custom-integrations:empty{margin-bottom:0;}/*!sc*/
data-styled.g512[id="sc-global-jTVnrn1"]{content:"sc-global-jTVnrn1,"}/*!sc*/
</style>





<meta data-react-helmet="true" content="Careers homepage" name="title"/><meta data-react-helmet="true" content="Careers homepage" property="og:title"/>

<script data-react-helmet="true" data-testid="custom-integrations-window-api">
        window.recruitee = window.recruitee || {};
        window.recruitee.customIntegrationsApi = window.recruitee.customIntegrationsApi || {"companyId":53295,"offerId":null,"offer":null};
      </script>
<title data-react-helmet="true">Careers homepage</title>




    <style>
      body > div[data-component="PublicApp"] {
        display: -webkit-box;
        display: -webkit-flex;
        display: -ms-flexbox;
        display: flex;
        -webkit-flex-direction: column;
        -ms-flex-direction: column;
        flex-direction: column;
        min-height: inherit;
      }
    </style>
  </head>
  <body>
<div data-rendered data-component="PublicApp" data-props="{&quot;appConfig&quot;:{&quot;agreements&quot;:[],&quot;analyticsBaseUrl&quot;:&quot;https://careers-analytics.recruitee.com&quot;,&quot;appEnv&quot;:&quot;production&quot;,&quot;atsHost&quot;:&quot;recruitee.com&quot;,&quot;captcha&quot;:{&quot;apiHost&quot;:&quot;https://captcha-base.recruiteecdn.com&quot;,&quot;assetHost&quot;:&quot;https://captcha-assets.recruiteecdn.com&quot;,&quot;imageHost&quot;:&quot;https://captcha-imgs.recruiteecdn.com&quot;,&quot;reportHost&quot;:&quot;https://captcha-report.recruiteecdn.com&quot;,&quot;siteKey&quot;:&quot;d111bc04-7616-4e05-a1da-9840968d2b88&quot;},&quot;cookiesConsent&quot;:{&quot;isEnabled&quot;:false,&quot;translations&quot;:{&quot;en&quot;:{&quot;agreeToAllCookies&quot;:&quot;Agree to all&quot;,&quot;agreeToNecessaryCookies&quot;:&quot;Agree to necessary&quot;,&quot;agreeToSelectedCookies&quot;:&quot;Agree to selected&quot;,&quot;bigCookiePlaceholderCta&quot;:&quot;Cookie preferences&quot;,&quot;bigCookiePlaceholderTitle&quot;:&quot;But first, cookies ;)&quot;,&quot;bigCookiePlaceholderVimeoDescription&quot;:&quot;We can&#39;t display this video. Please allow Vimeo cookies to watch it.&quot;,&quot;bigCookiePlaceholderYoutubeDescription&quot;:&quot;We can&#39;t display this video. Please allow YouTube cookies to watch it.&quot;,&quot;consentButtonLabel&quot;:null,&quot;description&quot;:null,&quot;dialogDescription&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;We use cookies to ensure that we give you the best experience on our website.&quot;}],&quot;type&quot;:&quot;p&quot;}],&quot;dialogTitle&quot;:&quot;Cookies agreement&quot;,&quot;hideSettings&quot;:&quot;Hide options&quot;,&quot;necessary&quot;:&quot;Necessary&quot;,&quot;necessaryCookies&quot;:&quot;Necessary cookies&quot;,&quot;necessaryCookiesDescription&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Some cookies are required to provide core functionality. The website might not function properly without these cookies, they are enabled by default and cannot be disabled.&quot;}],&quot;type&quot;:&quot;p&quot;}],&quot;optionalCookies&quot;:&quot;Optional cookies&quot;,&quot;showLess&quot;:&quot;Show less&quot;,&quot;showMore&quot;:&quot;Show more&quot;,&quot;showSettings&quot;:&quot;More options&quot;,&quot;smallCookiePlaceholderCta&quot;:&quot;Update cookies&quot;,&quot;smallCookiePlaceholderDescription&quot;:&quot;unavailable&quot;,&quot;title&quot;:null}},&quot;updatedAt&quot;:&quot;2000-01-01T00:00:00&quot;},&quot;customFontFamilies&quot;:[],&quot;departments&quot;:[{&quot;id&quot;:108703,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Development&quot;}}},{&quot;id&quot;:108710,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Administration&quot;}}},{&quot;id&quot;:129247,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;adm&quot;}}},{&quot;id&quot;:108708,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Strategy &amp; Project Management&quot;}}},{&quot;id&quot;:108702,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Design&quot;}}}],&quot;featureFlags&quot;:{&quot;applyWithXing&quot;:true,&quot;careersAnalytics&quot;:true,&quot;customCodeSection&quot;:true,&quot;customIntegrations&quot;:true,&quot;hcaptcha&quot;:true,&quot;internalPages&quot;:true,&quot;jobCoverImage&quot;:true,&quot;manageLocations&quot;:true,&quot;screeningQuestionDate&quot;:true,&quot;siteMigrator&quot;:true,&quot;texting&quot;:true},&quot;initialLocation&quot;:&quot;/&quot;,&quot;internalIntegrations&quot;:[{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;xing&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with XING feature. The Apply with XING feature allows you to apply for jobs by using your XING profile. When you click Apply with XING on our site, we&#39;ll pre-populate some of the job application fields with your profile data and automatically attach your complete XING profile to the application form. This means that we will be able to easily access your complete XING profile as we look through your application. For details about the cookies used and the data received see XING&#39;s Cookie Policy. Apply with XING is subject to XING&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://privacy.xing.com/en/privacy-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:1014388,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;XING&quot;,&quot;type&quot;:&quot;xing&quot;,&quot;updatedAt&quot;:&quot;2024-01-12T12:56:26&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[{&quot;category&quot;:&quot;necessary&quot;,&quot;key&quot;:null,&quot;name&quot;:&quot;_cs_consent&quot;,&quot;provenance&quot;:&quot;first-party&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Stores the user&#39;s cookie consent state for the current domain.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}}],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;careers&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null}}},&quot;id&quot;:458454,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;CareersHub&quot;,&quot;type&quot;:&quot;careers&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;google-analytics&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;We use Google Analytics to track visitor behaviour and measure site performance. For details about the cookies used and the data received see Google&#39;s Cookie Policy. Cookies placed by Google Analytics are subject to Google’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://policies.google.com/technologies/cookies&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458455,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;Google Analytics&quot;,&quot;settings&quot;:{&quot;token&quot;:&quot;&quot;},&quot;type&quot;:&quot;google-analytics&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;youtube&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables embedded YouTube player feature. For details about the cookies used and the data received see Google&#39;s Cookie Policy. Cookies placed by embedded YouTube players are subject to Google’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://policies.google.com/technologies/cookies&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458456,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Youtube&quot;,&quot;type&quot;:&quot;youtube&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;vimeo&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables embedded Vimeo player feature. For details about the cookies used and the data received see Vimeo&#39;s Cookie Policy. Cookies placed by embedded Vimeo players are subject to Vimeo’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://vimeo.com/cookie_policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458457,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Vimeo&quot;,&quot;type&quot;:&quot;vimeo&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;linkedin&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with LinkedIn feature. The Apply with LinkedIn feature allows you to apply for jobs by using your LinkedIn profile. When you click Apply with LinkedIn on our site, we&#39;ll pre-populate some of the job application fields with your profile data and automatically attach your complete LinkedIn profile to the application form. This means that we will be able to easily access your complete LinkedIn profile as we look through your application. For details about the cookies used and the data received see LinkedIn&#39;s Cookie Policy. Apply with LinkedIn is subject to LinkedIn&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.linkedin.com/legal/cookie-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458458,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;LinkedIn&quot;,&quot;settings&quot;:{&quot;isApplyWithLinkedInOn&quot;:true},&quot;type&quot;:&quot;linkedin&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;indeed&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with Indeed feature. The Apply with Indeed feature allows you to quickly apply using an Indeed Resume. For details about the cookies used and the data received see Indeed&#39;s Privacy Policy. Apply with Indeed is subject to Indeed&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Privacy Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.indeed.com/legal&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458459,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Indeed&quot;,&quot;settings&quot;:{&quot;isApplyWithIndeedOn&quot;:true},&quot;type&quot;:&quot;indeed&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;kununu&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables kununu Live Score feature. The kununu Live Score feature allows you to view our current kununu employer score. For details about the cookies used and the data received see kununu&#39;s privacy policy. kununu Live Score is subject to kununu’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Privacy Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://privacy.xing.com/en/privacy-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:680112,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;kununu&quot;,&quot;type&quot;:&quot;kununu&quot;,&quot;updatedAt&quot;:&quot;2021-11-09T16:58:54&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;facebook-pixel&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Allows us to measure the effectiveness of our advertising by understanding the actions that visitors take on our website. For details about the cookies used and the data received see Facebook&#39;s Cookie Policy. Cookies placed by Facebook Pixel are subject to Facebook&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.facebook.com/policies/cookies/&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:811110,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;Facebook Pixel&quot;,&quot;settings&quot;:{&quot;pixelId&quot;:&quot;&quot;},&quot;type&quot;:&quot;facebook-pixel&quot;,&quot;updatedAt&quot;:&quot;2022-06-14T19:53:57&quot;}],&quot;isApplicationFormApplicationDisabled&quot;:null,&quot;isOfferAtsPreview&quot;:null,&quot;isOfferMockFallbackAllowed&quot;:null,&quot;languages&quot;:{&quot;en&quot;:&quot;English&quot;},&quot;offers&quot;:[{&quot;city&quot;:&quot;New York&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108703,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1333509,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;pwpku&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:813298,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91709,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;New York&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;New York&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:42,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;developer-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Developer Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Developer Talent Pool&quot;}}},{&quot;city&quot;:&quot;Brooklyn&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108708,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1357326,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;optional&quot;,&quot;photo&quot;:&quot;off&quot;},&quot;guid&quot;:&quot;u4kva&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:782556,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91708,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;Brooklyn&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;Brooklyn, 11201 (2)&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:&quot;11201&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:&quot;20 Jay Street&quot;}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:false,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:43,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:&quot;USD&quot;,&quot;max&quot;:6.8e4,&quot;min&quot;:5.2e4,&quot;period&quot;:&quot;year&quot;},&quot;slug&quot;:&quot;project-manager-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:&quot;20 Jay Street&quot;,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a &quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Project Manager Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Project Manager Talent Pool&quot;}}},{&quot;city&quot;:&quot;New York&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108702,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1333465,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;2ccy3&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:813299,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91709,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;New York&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;New York&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:41,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;design-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;We are always looking for passionate, talented designers to join our team but don&#39;t always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Design Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Design Talent Pool&quot;}}},{&quot;city&quot;:&quot;BROOKLYN&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:null,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1390320,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;56ucy&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:814442,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91700,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;BROOKLYN&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;BROOKLYN&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:45,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;copywriter-talen-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Copywriter Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Copywriter Talent Pool&quot;}}}],&quot;page&quot;:{&quot;id&quot;:79071,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Careers homepage&quot;,&quot;position&quot;:1,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:251668,&quot;revision&quot;:{&quot;id&quot;:251668,&quot;insertedAt&quot;:&quot;2021-10-19T23:22:49Z&quot;,&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;header&quot;:null,&quot;name&quot;:null,&quot;settings&quot;:{&quot;contentPadding&quot;:&quot;none&quot;,&quot;header&quot;:null,&quot;isHeaderOn&quot;:false,&quot;layout&quot;:&quot;single-column&quot;,&quot;singleColumnLayout&quot;:{&quot;columnAlignment&quot;:&quot;left&quot;,&quot;columnWidth&quot;:12},&quot;textAlignment&quot;:&quot;center&quot;,&quot;textBackgroundColor&quot;:null,&quot;twoColumnLayout&quot;:{&quot;columnGap&quot;:&quot;large&quot;,&quot;columnRatio&quot;:&quot;1:1&quot;,&quot;stretchBackgroundEnabled&quot;:false,&quot;verticalAlignment&quot;:&quot;top&quot;}},&quot;theme&quot;:{&quot;actionColor&quot;:&quot;#fff&quot;,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:{&quot;height&quot;:834,&quot;imageId&quot;:7621,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/HcU/sWb17AUkqGgp.png&quot;,&quot;width&quot;:2288},&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:&quot;image&quot;,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;contentVerticalAlignment&quot;:&quot;center&quot;,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:&quot;#fff&quot;,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:true,&quot;isMinHeightOn&quot;:true,&quot;minHeight&quot;:&quot;medium&quot;,&quot;paddingBottom&quot;:&quot;large&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:&quot;#fff&quot;,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;translations&quot;:{&quot;en&quot;:{&quot;firstColumn&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;type&quot;:&quot;h1&quot;}]},&quot;secondColumn&quot;:{&quot;body&quot;:[],&quot;image&quot;:null}}},&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;e7405c08-6f63-4915-adcf-f85bb4aa397a&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Current openings&quot;}],&quot;type&quot;:&quot;h2&quot;}]}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;areFiltersOn&quot;:null,&quot;areGroupsOn&quot;:false,&quot;areTabsOn&quot;:false,&quot;cardsLayoutSettings&quot;:{&quot;areLanguagesOn&quot;:null,&quot;areTagsOn&quot;:null,&quot;backgroundColor&quot;:null,&quot;buttonPosition&quot;:&quot;aside&quot;,&quot;buttonText&quot;:null,&quot;columns&quot;:2,&quot;gap&quot;:&quot;medium&quot;,&quot;innerPadding&quot;:null,&quot;isButtonOn&quot;:true,&quot;isDepartmentOn&quot;:null,&quot;isLocationCityOn&quot;:null,&quot;isLocationCountryOn&quot;:null,&quot;isLocationNameOn&quot;:null,&quot;isLocationNoteOn&quot;:null,&quot;isLocationOn&quot;:null,&quot;isLocationRemoteOn&quot;:null,&quot;isLocationStateOn&quot;:null,&quot;isLocationStreetOn&quot;:null,&quot;isSalaryOn&quot;:null,&quot;titleSize&quot;:&quot;regular&quot;},&quot;filtersSettings&quot;:{&quot;defaultCountriesPerLanguage&quot;:[],&quot;defaultJobLanguagesPerPageLanguage&quot;:[],&quot;isCityFilterOn&quot;:true,&quot;isCountryFilterOn&quot;:true,&quot;isDepartmentFilterOn&quot;:false,&quot;isHeadingOn&quot;:true,&quot;isLanguageFilterOn&quot;:null,&quot;isRemoteFilterOn&quot;:null,&quot;isSearchOn&quot;:true,&quot;isStateFilterOn&quot;:false,&quot;isTagFilterOn&quot;:false,&quot;layout&quot;:&quot;boxed&quot;,&quot;position&quot;:&quot;top&quot;},&quot;groupsSettings&quot;:{&quot;groupBy&quot;:null,&quot;jobCounterVariant&quot;:null,&quot;position&quot;:null},&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:null,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:null,&quot;horizontalLayoutWidth&quot;:null,&quot;isBackgroundStretchOn&quot;:null,&quot;isCustomColored&quot;:null,&quot;padding&quot;:null,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:null,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:null,&quot;verticalLayoutWidth&quot;:null},&quot;isHeaderOn&quot;:true,&quot;isPaginationOn&quot;:null,&quot;layout&quot;:&quot;table&quot;,&quot;paginationSettings&quot;:null,&quot;prefiltersSettings&quot;:null,&quot;sortBy&quot;:null,&quot;tableLayoutSettings&quot;:{&quot;buttonText&quot;:null,&quot;isButtonOn&quot;:true,&quot;isDepartmentColumnOn&quot;:null,&quot;isLanguagesColumnOn&quot;:null,&quot;isLocationCityOn&quot;:null,&quot;isLocationColumnOn&quot;:false,&quot;isLocationCountryOn&quot;:null,&quot;isLocationNameOn&quot;:null,&quot;isLocationNoteOn&quot;:null,&quot;isLocationRemoteOn&quot;:null,&quot;isLocationStateOn&quot;:null,&quot;isLocationStreetOn&quot;:null,&quot;isSalaryColumnOn&quot;:null,&quot;isTagsColumnOn&quot;:null,&quot;spacing&quot;:&quot;spacious&quot;},&quot;tabsSettings&quot;:{&quot;jobCounterVariant&quot;:null,&quot;position&quot;:&quot;top&quot;,&quot;size&quot;:&quot;regular&quot;,&quot;tabBy&quot;:null}},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:null,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:&quot;top&quot;,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:true,&quot;minHeight&quot;:&quot;small&quot;,&quot;paddingBottom&quot;:&quot;large&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;OfferList&quot;,&quot;uuid&quot;:&quot;c88dea0d-b17f-4245-a020-9167e1e2bac0&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Our Philosophy&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We have a lot of fun together, something we consider to be really important. The creative process isn’t easy, but enjoying the journey is something we do well. We love what we do, and we think you’ll love working with us.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;image&quot;:{&quot;image&quot;:{&quot;height&quot;:1080,&quot;imageId&quot;:8800,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/ImA/Z18mPRgadPTx.jpeg&quot;,&quot;width&quot;:1080},&quot;translations&quot;:{&quot;en&quot;:{&quot;alt&quot;:&quot;some text&quot;}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;customImageWidth&quot;:100,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;left&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/2&quot;,&quot;isBackgroundStretchOn&quot;:true,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;extra-large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;left&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;center&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;horizontalAlignment&quot;:&quot;center&quot;,&quot;imageWidth&quot;:&quot;custom&quot;,&quot;isHeaderOn&quot;:true},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;small&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;fb8d4333-6abd-414e-aa18-d639f3f169ef&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Our Clients&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;From powerhouses like the Brooklyn Navy Yard, Sesame Workshop, Vital Strategies, and Columbia University, to global movers and shakers like The American Cancer Society, United Nations, the International Rescue Committee, UNICEF, and Women’s Refugee Commission, we’ve worked together to solve some big problems and increase their impact.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;image&quot;:{&quot;image&quot;:{&quot;height&quot;:1080,&quot;imageId&quot;:8801,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/ImE/pqy0lEe95RqO.jpeg&quot;,&quot;width&quot;:1080},&quot;translations&quot;:{&quot;en&quot;:{&quot;alt&quot;:&quot;some text&quot;}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;customImageWidth&quot;:100,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;right&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/2&quot;,&quot;isBackgroundStretchOn&quot;:true,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;extra-large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;left&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;center&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;horizontalAlignment&quot;:&quot;center&quot;,&quot;imageWidth&quot;:&quot;custom&quot;,&quot;isHeaderOn&quot;:true},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;medium&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;c316b05d-aac8-4c48-995f-5b177342df19&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:null,&quot;name&quot;:null,&quot;settings&quot;:{&quot;contentPadding&quot;:&quot;small&quot;,&quot;header&quot;:null,&quot;isHeaderOn&quot;:false,&quot;layout&quot;:&quot;single-column&quot;,&quot;singleColumnLayout&quot;:{&quot;columnAlignment&quot;:&quot;center&quot;,&quot;columnWidth&quot;:12},&quot;textAlignment&quot;:&quot;left&quot;,&quot;textBackgroundColor&quot;:null,&quot;twoColumnLayout&quot;:{&quot;columnGap&quot;:&quot;small&quot;,&quot;columnRatio&quot;:&quot;1:1&quot;,&quot;stretchBackgroundEnabled&quot;:false,&quot;verticalAlignment&quot;:&quot;center&quot;}},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;translations&quot;:{&quot;en&quot;:{&quot;firstColumn&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_self&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;/&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;Join a team of kind, curious, and empathetic individuals&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Radish Lab is a creative agency that believes that good design can help solve big challenges. We partner with organizations that are looking to create greater impact in their work and the world around them.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We believe good design is clear, simple, and engaging. And we believe that good design has the power to move you.We focus on helping social change projects and organizations tell compelling digital stories, deeply engage their audiences, and apply smart creative and technical solutions to some pretty impressive challenges.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;With offices in Brooklyn and Berlin, we love helping our clients create and tell compelling visual stories. &quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Radish Lab is also a certified B Corporation, which means we’re held accountable for meeting the highest standards of overall social and environmental performance, transparency and accountability.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;type&quot;:&quot;p&quot;}]},&quot;secondColumn&quot;:{&quot;body&quot;:[],&quot;image&quot;:null}}},&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;f4523764-61b1-476e-9c60-90a3171bc222&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;SELECTED CLIENTS&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We partner with organizations, activists and optimists. Here’s a handful we’ve already helped.&quot;}],&quot;type&quot;:&quot;h3&quot;}]}}},&quot;items&quot;:[{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8792,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilg/KFkAhPsAE6m7.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8793,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilk/lVkUsYEyvKky.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8794,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilo/S5EkxjRNYf4U.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8795,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ils/UcXAqrsyzCFC.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8796,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilw/5vZK251ADpLK.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8797,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il0/mJUUpYFqt7ny.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8798,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il4/J3g5SeRl41JZ.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8799,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il8/pXhL2Ip7Ng1z.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null}],&quot;name&quot;:null,&quot;settings&quot;:{&quot;borderRadius&quot;:0,&quot;carousel&quot;:null,&quot;columnCount&quot;:4,&quot;gap&quot;:&quot;small&quot;,&quot;grid&quot;:{&quot;emphasizedItems&quot;:[{&quot;columnCount&quot;:2,&quot;settings&quot;:[{&quot;columnIndex&quot;:0,&quot;rowIndex&quot;:1},{&quot;columnIndex&quot;:0,&quot;rowIndex&quot;:2}]},{&quot;columnCount&quot;:3,&quot;settings&quot;:[{&quot;columnIndex&quot;:1,&quot;rowIndex&quot;:1},{&quot;columnIndex&quot;:1,&quot;rowIndex&quot;:2},{&quot;columnIndex&quot;:2,&quot;rowIndex&quot;:0}]}]},&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;medium&quot;,&quot;headerPosition&quot;:&quot;top&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/4&quot;,&quot;isBackgroundStretchOn&quot;:false,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;none&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;center&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;top&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;isHeaderOn&quot;:true,&quot;isLightboxOn&quot;:null,&quot;layout&quot;:&quot;grid&quot;,&quot;masonry&quot;:{&quot;heightSettings&quot;:{&quot;firstRow&quot;:[{&quot;columnIndex&quot;:1,&quot;heightMultiplier&quot;:1.0},{&quot;columnIndex&quot;:3,&quot;heightMultiplier&quot;:1.5}],&quot;lastRow&quot;:[{&quot;columnIndex&quot;:0,&quot;heightMultiplier&quot;:1.0},{&quot;columnIndex&quot;:1,&quot;heightMultiplier&quot;:1.0}]},&quot;widthSettings&quot;:[{&quot;columnCount&quot;:2,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[4,8],&quot;rowIndex&quot;:0}]},{&quot;columnCount&quot;:3,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[3,4,5],&quot;rowIndex&quot;:0}]},{&quot;columnCount&quot;:4,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[4,2,2,4],&quot;rowIndex&quot;:0}]}]},&quot;rowAlignment&quot;:&quot;center&quot;},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:&quot;center&quot;,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;ImageCollection&quot;,&quot;uuid&quot;:&quot;6808b50d-8984-4888-8f76-4fbff8bb3e67&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;OUR OFFICE&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Brooklyn – DUMBO&quot;}],&quot;type&quot;:&quot;h3&quot;}]}}},&quot;map&quot;:{&quot;markers&quot;:[{&quot;address&quot;:&quot;20 Jay Street, Brooklyn, New York 11201, United States&quot;,&quot;latitude&quot;:&quot;40.704097&quot;,&quot;longitude&quot;:&quot;-73.98688&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:&quot;&quot;,&quot;title&quot;:&quot;Brooklyn&quot;}}}]},&quot;name&quot;:null,&quot;settings&quot;:{&quot;areMapControlsOn&quot;:true,&quot;gap&quot;:&quot;small&quot;,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;top&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/4&quot;,&quot;isBackgroundStretchOn&quot;:false,&quot;isCustomColored&quot;:null,&quot;padding&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;center&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;top&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;isHeaderOn&quot;:true,&quot;mapAlignment&quot;:&quot;center&quot;,&quot;mapHeight&quot;:&quot;medium&quot;,&quot;mapTilesStyle&quot;:&quot;streets-v11&quot;,&quot;mapWidth&quot;:12},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:&quot;center&quot;,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;medium&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Map&quot;,&quot;uuid&quot;:&quot;cb09dc8f-0334-4c29-9278-7141395f4bf7&quot;}]},&quot;slug&quot;:&quot;homepage&quot;,&quot;status&quot;:&quot;published&quot;,&quot;theme&quot;:{&quot;actionColor&quot;:&quot;#000000&quot;,&quot;backgroundColor&quot;:&quot;#fff&quot;,&quot;buttonFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;buttonFontStyle&quot;:null,&quot;buttonFontTransform&quot;:null,&quot;buttonFontWeight&quot;:&quot;600&quot;,&quot;default&quot;:true,&quot;footer&quot;:{&quot;areLinksOn&quot;:false,&quot;areSocialLinksOn&quot;:false,&quot;isFooterOn&quot;:null,&quot;languagePicker&quot;:null,&quot;links&quot;:[],&quot;logo&quot;:null,&quot;logoLink&quot;:null,&quot;logoMaxHeight&quot;:null,&quot;logoWithAlt&quot;:null,&quot;socialLinks&quot;:[],&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:null,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:null,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:null,&quot;paddingTop&quot;:null,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null}},&quot;headingColor&quot;:&quot;#000000&quot;,&quot;headingFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;headingFontStyle&quot;:null,&quot;headingFontTransform&quot;:null,&quot;headingFontWeight&quot;:&quot;600&quot;,&quot;id&quot;:39544,&quot;name&quot;:&quot;Default&quot;,&quot;navigation&quot;:{&quot;button&quot;:null,&quot;colorSchemeSource&quot;:null,&quot;contentBoundary&quot;:null,&quot;fixedNavigationLogo&quot;:null,&quot;fixedNavigationLogoWithAlt&quot;:null,&quot;fixedNavigationTheme&quot;:null,&quot;fixedNavigationType&quot;:null,&quot;isFixed&quot;:null,&quot;languagePicker&quot;:null,&quot;layout&quot;:null,&quot;links&quot;:[{&quot;items&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null,&quot;label&quot;:&quot;Company website&quot;,&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:null,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.radishlab.com/&quot;},&quot;url&quot;:null}},&quot;type&quot;:null}],&quot;logo&quot;:{&quot;height&quot;:312,&quot;imageId&quot;:10003,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/JxM/erKO0TGNyJ6_.png&quot;,&quot;width&quot;:1118},&quot;logoLink&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null,&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:79071,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:null,&quot;type&quot;:&quot;page&quot;,&quot;url&quot;:null}}}},&quot;logoMaxHeight&quot;:null,&quot;logoWithAlt&quot;:null,&quot;socialLinks&quot;:[{&quot;translations&quot;:{&quot;en&quot;:{&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:null,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.instagram.com/radishlab/&quot;},&quot;url&quot;:null}},&quot;type&quot;:&quot;instagram&quot;}],&quot;theme&quot;:null},&quot;pageIds&quot;:[79072,281476,79071],&quot;primaryButtonTextColor&quot;:null,&quot;recruiteeBranding&quot;:null,&quot;textColor&quot;:&quot;#000000&quot;,&quot;textFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;textFontSize&quot;:null,&quot;textFontStyle&quot;:null,&quot;textFontTransform&quot;:null,&quot;textFontWeight&quot;:&quot;400&quot;},&quot;translations&quot;:{},&quot;type&quot;:&quot;homepage&quot;,&quot;visibility&quot;:&quot;public&quot;},&quot;pages&quot;:[{&quot;id&quot;:79071,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Careers homepage&quot;,&quot;position&quot;:1,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:251668,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;e7405c08-6f63-4915-adcf-f85bb4aa397a&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;OfferList&quot;,&quot;uuid&quot;:&quot;c88dea0d-b17f-4245-a020-9167e1e2bac0&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;fb8d4333-6abd-414e-aa18-d639f3f169ef&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;c316b05d-aac8-4c48-995f-5b177342df19&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;f4523764-61b1-476e-9c60-90a3171bc222&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;ImageCollection&quot;,&quot;uuid&quot;:&quot;6808b50d-8984-4888-8f76-4fbff8bb3e67&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Map&quot;,&quot;uuid&quot;:&quot;cb09dc8f-0334-4c29-9278-7141395f4bf7&quot;}]},&quot;slug&quot;:&quot;homepage&quot;,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;homepage&quot;,&quot;visibility&quot;:&quot;public&quot;},{&quot;id&quot;:79072,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Offer details&quot;,&quot;position&quot;:2,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:250726,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;OfferHeadline&quot;,&quot;uuid&quot;:&quot;a8e9c04b-733b-4245-b54f-45e388a6d718&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Offer&quot;,&quot;uuid&quot;:&quot;fd8097f3-6dc5-4dff-96ab-ff3e71e23837&quot;}]},&quot;slug&quot;:null,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;offer_details&quot;,&quot;visibility&quot;:&quot;public&quot;},{&quot;id&quot;:281476,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;We couldn&#39;t find this job&quot;,&quot;position&quot;:0,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:409485,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;JobNotFound&quot;,&quot;uuid&quot;:null}]},&quot;slug&quot;:null,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;job_not_found&quot;,&quot;visibility&quot;:&quot;public&quot;}],&quot;sentryEnv&quot;:&quot;production&quot;,&quot;site&quot;:{&quot;advancedSettings&quot;:{&quot;internalJobsListing&quot;:&quot;disabled&quot;},&quot;awliApiKey&quot;:null,&quot;awliIntegrationContext&quot;:null,&quot;captcha&quot;:&quot;invisible&quot;,&quot;careersAnalyticsEnabled&quot;:true,&quot;companyLangCodes&quot;:[&quot;en&quot;],&quot;cookieConsentEnabled&quot;:false,&quot;customCss&quot;:null,&quot;customHtmlBody&quot;:null,&quot;customHtmlHead&quot;:null,&quot;defaultOgImageUrl&quot;:&quot;https://careers.recruiteecdn.com/image/upload/share_image_w6am4m.png&quot;,&quot;domainActivated&quot;:false,&quot;eeo&quot;:{&quot;isEnabled&quot;:false,&quot;kind&quot;:&quot;eeo&quot;},&quot;externalId&quot;:53295,&quot;host&quot;:&quot;radishlab.recruitee.com&quot;,&quot;id&quot;:39590,&quot;kununuHash&quot;:null,&quot;kununuLink&quot;:null,&quot;langCodes&quot;:[&quot;en&quot;],&quot;migrationDate&quot;:null,&quot;name&quot;:&quot;Radish Lab&quot;,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publicTranslations&quot;:{&quot;en&quot;:{&quot;shareFilteredJobsList&quot;:&quot;Share filtered jobs list&quot;,&quot;allCities&quot;:&quot;All cities&quot;,&quot;applicationSuccessDescription&quot;:&quot;Your application has been successfully submitted!&quot;,&quot;carouselPreviousSlideLabel&quot;:&quot;Previous slide&quot;,&quot;allDepartments&quot;:&quot;All departments&quot;,&quot;remote&quot;:&quot;Remote&quot;,&quot;stateFilterLabel&quot;:&quot;Select states/regions to filter offers by&quot;,&quot;allLanguages&quot;:&quot;All languages&quot;,&quot;xingCvNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;searchOffersLabel&quot;:&quot;Enter search query to filter offers by&quot;,&quot;cvFormatAllowedExtensions&quot;:&quot;Accepted files: PDF, DOC, DOCX, JPEG and PNG up to 50MB.&quot;,&quot;workModelFilterLabel&quot;:&quot;Select work model to filter offers by&quot;,&quot;shareJob&quot;:&quot;Share job&quot;,&quot;tooLargeFile&quot;:&quot;This file is too large&quot;,&quot;languages&quot;:&quot;Available languages&quot;,&quot;skipToContent&quot;:&quot;Skip to content&quot;,&quot;xingNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;departmentFilterLabel&quot;:&quot;Select departments to filter offers by&quot;,&quot;dragAndDrop&quot;:&quot;or drag and drop here&quot;,&quot;xingClearProfileData&quot;:&quot;Clear profile data&quot;,&quot;clearTextAndUploadFile&quot;:&quot;Clear text and upload a file instead&quot;,&quot;xJobs&quot;:&quot;%{jobsCount} jobs&quot;,&quot;viewJob&quot;:&quot;View job&quot;,&quot;jobDoesntExist&quot;:&quot;This job doesn’t exist or was removed.&quot;,&quot;emailPlaceholder&quot;:&quot;Your email address&quot;,&quot;offerTitle&quot;:&quot;Job title&quot;,&quot;textingConsent&quot;:&quot;I consent to be contacted via text messages for this and any other job within %{companyName}.&quot;,&quot;phonePlaceholder&quot;:&quot;Your phone number&quot;,&quot;applicationSuccessHeading&quot;:&quot;All done!&quot;,&quot;xMore&quot;:&quot;%{count} more&quot;,&quot;orApplyWith&quot;:&quot;or&quot;,&quot;carouselNextSlideLabel&quot;:&quot;Next slide&quot;,&quot;insertEmailAddress&quot;:&quot;This email address is invalid. Please enter a valid email address (for example, name@example.com).&quot;,&quot;yesAnswer&quot;:&quot;Yes&quot;,&quot;hybrid&quot;:&quot;Hybrid&quot;,&quot;perYear&quot;:&quot;%{range} per year&quot;,&quot;applicationSuccessButtonLabel&quot;:&quot;Other jobs&quot;,&quot;locationNoteTooltip&quot;:&quot;Location note tooltip&quot;,&quot;agreementsLabel&quot;:&quot;Legal Agreements&quot;,&quot;phoneLabel&quot;:&quot;Phone number&quot;,&quot;emptyPage&quot;:&quot;This page is empty&quot;,&quot;city&quot;:&quot;City&quot;,&quot;clearFilters&quot;:&quot;Clear&quot;,&quot;extensionError&quot;:&quot;allowed file types&quot;,&quot;offerListNoOffers&quot;:&quot;Currently we don&#39;t have any open positions.&quot;,&quot;salary&quot;:&quot;Salary&quot;,&quot;personalInformationHint&quot;:&quot;Fill out the information below&quot;,&quot;insertValidPhoneNumber&quot;:&quot;This phone number is invalid. Please enter a valid phone number, including the country calling code.&quot;,&quot;applyForm&quot;:&quot;Application&quot;,&quot;coverLetterButtonWriteHere&quot;:&quot;Write it here instead&quot;,&quot;international&quot;:&quot;International&quot;,&quot;enterText&quot;:&quot;Enter text&quot;,&quot;linkedInNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;coverLetterLabel&quot;:&quot;Cover letter&quot;,&quot;languageFilterLabel&quot;:&quot;Select languages to filter offers by&quot;,&quot;requiredFieldsDescription&quot;:&quot;All fields marked with * are required.&quot;,&quot;questionsHint&quot;:&quot;Please fill in additional questions&quot;,&quot;cvLabel&quot;:&quot;CV or resume&quot;,&quot;showFiltersButtonText&quot;:&quot;Show filters&quot;,&quot;imageCollectionEmptyDescription&quot;:&quot;Image collection is empty&quot;,&quot;cvHint&quot;:&quot;Upload your CV or resume file&quot;,&quot;jobNotFound&quot;:&quot;We couldn’t find this job&quot;,&quot;tooManyFiles&quot;:&quot;Too many files&quot;,&quot;questionsLabel&quot;:&quot;Questions&quot;,&quot;showMoreJobs&quot;:&quot;Show more jobs&quot;,&quot;send&quot;:&quot;Send&quot;,&quot;location&quot;:&quot;Location&quot;,&quot;workModel&quot;:&quot;Work model&quot;,&quot;applied&quot;:&quot;Applied&quot;,&quot;allStates&quot;:&quot;All states/regions&quot;,&quot;offerListNoOffersMatchingFilters&quot;:&quot;No open positions matching selected filters.&quot;,&quot;offerListFiltersHeading&quot;:&quot;Filters&quot;,&quot;copied&quot;:&quot;Copied&quot;,&quot;tags&quot;:&quot;Tags&quot;,&quot;showingXOfY&quot;:&quot;Showing %{visibleJobsCount} of %{jobsCount}&quot;,&quot;coverLetterButtonClearAndUpload&quot;:&quot;Clear and upload a cover letter instead&quot;,&quot;coverLetterHint&quot;:&quot;Insert your cover letter here&quot;,&quot;applyWithIndeed&quot;:&quot;Apply with Indeed&quot;,&quot;fieldRequired&quot;:&quot;This field is required and can not be left empty.&quot;,&quot;details&quot;:&quot;Details&quot;,&quot;clearDateButton&quot;:&quot;Clear&quot;,&quot;onSite&quot;:&quot;On-site&quot;,&quot;department&quot;:&quot;Department&quot;,&quot;tag&quot;:&quot;Tag&quot;,&quot;perHour&quot;:&quot;%{range} per hour&quot;,&quot;namePlaceholder&quot;:&quot;Full name&quot;,&quot;uploadFile&quot;:&quot;Upload a file&quot;,&quot;hideFiltersButtonText&quot;:&quot;Hide filters&quot;,&quot;applyWithXing&quot;:&quot;Apply With XING&quot;,&quot;close&quot;:&quot;Close&quot;,&quot;homepage&quot;:&quot;Homepage&quot;,&quot;countryFilterLabel&quot;:&quot;Select countries to filter offers by&quot;,&quot;offerRequirements&quot;:&quot;Job requirements&quot;,&quot;offerDescription&quot;:&quot;Job description&quot;,&quot;present&quot;:&quot;Present&quot;,&quot;noAnswer&quot;:&quot;No&quot;,&quot;allTags&quot;:&quot;All tags&quot;,&quot;coverLetterHintFileUpload&quot;:&quot;Upload your cover letter&quot;,&quot;country&quot;:&quot;Country&quot;,&quot;changeFile&quot;:&quot;Change file&quot;,&quot;shareTo&quot;:&quot;Share to&quot;,&quot;nameLabel&quot;:&quot;Full name&quot;,&quot;filenameBlankError&quot;:&quot;Filename can&#39;t be blank&quot;,&quot;link&quot;:&quot;Link&quot;,&quot;offerListTabsLabel&quot;:&quot;Select tab to filter offers by&quot;,&quot;searchOffers&quot;:&quot;Search offers...&quot;,&quot;play&quot;:&quot;Play&quot;,&quot;goToHomepage&quot;:&quot;Go to homepage&quot;,&quot;remoteJob&quot;:&quot;Remote job&quot;,&quot;linkedInCvNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;noDepartment&quot;:&quot;No department&quot;,&quot;unsafeError&quot;:&quot;is unsafe&quot;,&quot;copy&quot;:&quot;Copy&quot;,&quot;linkedInClearProfileData&quot;:&quot;Clear profile data&quot;,&quot;invalidError&quot;:&quot;is invalid&quot;,&quot;applyWith&quot;:&quot;Apply with&quot;,&quot;blankError&quot;:&quot;can&#39;t be blank&quot;,&quot;phoneCallingCodeLabel&quot;:&quot;Select country calling code&quot;,&quot;photoLabel&quot;:&quot;Photo&quot;,&quot;allCountries&quot;:&quot;All countries&quot;,&quot;removeFile&quot;:&quot;Remove&quot;,&quot;invalidFileType&quot;:&quot;Invalid file type&quot;,&quot;tagFilterLabel&quot;:&quot;Select tags to filter offers by&quot;,&quot;emailLabel&quot;:&quot;Email address&quot;,&quot;apply&quot;:&quot;Apply&quot;,&quot;offerListNoOffersMatchingPrefilters&quot;:&quot;No open positions.&quot;,&quot;departments&quot;:&quot;Departments&quot;,&quot;moreLocationsTooltip&quot;:&quot;More locations tooltip&quot;,&quot;perMonth&quot;:&quot;%{range} per month&quot;,&quot;share&quot;:&quot;Share&quot;,&quot;skipToCookieConsent&quot;:&quot;Skip to Cookie Consent&quot;,&quot;photoFormatAllowedExtensions&quot;:&quot;Accepted files: PNG, JPG and JPEG up to 20MB.&quot;,&quot;textingConsentHeader&quot;:&quot;SMS consent&quot;,&quot;pageNavigationLabel&quot;:&quot;Page navigation&quot;,&quot;cityFilterLabel&quot;:&quot;Select cities to filter offers by&quot;,&quot;personalInformationLabel&quot;:&quot;My information&quot;,&quot;noState&quot;:&quot;No state/region&quot;,&quot;state&quot;:&quot;State&quot;,&quot;coverLetterFileAllowedFormats&quot;:&quot;We accept PDF, DOC, DOCX, JPG and PNG files.&quot;,&quot;coverLetterHintTextArea&quot;:&quot;Write your cover letter here&quot;,&quot;offerDetails&quot;:&quot;Job details&quot;}},&quot;redirectToCustomDomain&quot;:true,&quot;subdomain&quot;:&quot;radishlab&quot;,&quot;textingSettingsEnabled&quot;:false,&quot;translations&quot;:{&quot;en&quot;:{&quot;ogImage&quot;:{&quot;height&quot;:418,&quot;imageId&quot;:66150,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/AQJm/eTpqtQ6sZ9sc.jpeg&quot;,&quot;width&quot;:800}}},&quot;updatedAt&quot;:&quot;2024-07-27T22:05:18&quot;}}}"><div></div><div class="sc-q8cmux-0 gBDROR"><a class="sc-q8cmux-1 kJsRIK" href="#content" data-reach-skip-link="" data-reach-skip-nav-link="">Skip to content</a></div><div class="sc-73r8cv-1 ilRiFP"><div data-scroll-point="section-navigation"><div class="sc-z9o81a-0 kllnfT"><div class="sc-z9o81a-1 fsBFXt"><div data-cy="navigation-section-position" style="font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;color:#fff;background-color:rgba(0, 0, 0, 0)" class="sc-3k6t01-0 jLGbJs"><div data-cy="navigation-section-grid-container" class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-0 dYPHZW"><div class="sc-1aabq8s-0 sc-1aabq8s-1 kJLltb"><a class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo" href="/"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" data-cy="navigation-section-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></a><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 kpwRdG"><nav><ul class="sc-1aabq8s-2 sc-1aabq8s-3 sc-1xewqye-0 hdTF"><li class="sc-1aabq8s-4 kcKagb"><a data-cy="navigation-section-link-item" href="https://www.radishlab.com/" target="_blank" rel="noopener" class="sc-ir8rf5-0 dPcHAE">Company website</a></li><li class="sc-1aabq8s-4 kcKagb"><a data-cy="navigation-section-social-link-item" href="https://www.instagram.com/radishlab/" target="_blank" title="instagram" rel="noopener" class="sc-7glywv-0 hlNgLl"><span class="sc-1rd450u-0 bIScAX"><svg width="18" height="18" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></a></li></ul></nav></div></div><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-1 ciZwhu"><div class="sc-1aabq8s-0 sc-1aabq8s-1 sc-1hkznj2-0 cghDST"><a class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo" href="/"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" data-cy="navigation-section-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></a><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 sc-1hkznj2-1 guEbMs"><div class="sc-1tx5im8-0 iudIDi"><button aria-live="polite" type="button" aria-haspopup="true" aria-controls="menu" aria-label="Page navigation" data-reach-menu-button="" class="sc-s03za1-0 eDCgIN sc-1km6n6q-1 sc-1tu9xny-2 iPvmIC"><span class="sc-1rd450u-0 bIScAX"><svg height="12" width="18" viewBox="0 0 18 12"><path d="M0 12h18v-2H0v2Zm0-5h18V5H0v2Zm0-7v2h18V0H0Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg></span></button><div data-reach-menu="" data-reach-menu-popover="" hidden="" class="sc-1tu9xny-4 sc-1tx5im8-1 hBOHsL"><div role="menu" tabindex="-1" data-reach-menu-items="" id="menu" style="background-color:#fff" class="sc-1tu9xny-0 hLPFpI"><div role="none" tabindex="-1"><a role="menuitem" tabindex="-1" href="https://www.radishlab.com/" target="_blank" data-reach-menu-link="" data-reach-menu-item="" data-selected="" data-valuetext="" class="sc-1tu9xny-1 kZTElj">Company website</a></div><div role="none" tabindex="-1"><a role="menuitem" tabindex="-1" href="https://www.instagram.com/radishlab/" aria-label="instagram" target="_BLANK" rel="noopener" style="display:inline-flex" data-reach-menu-link="" data-reach-menu-item="" data-selected="" data-valuetext="" class="sc-1tu9xny-1 kZTElj"><span class="sc-1rd450u-0 bIScAX"><svg width="15" height="15" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></a></div></div></div></div></div></div></div></div></div></div></div></div><div id="content" data-reach-skip-nav-content=""></div><main class="sc-73r8cv-0 homvAg"><div data-scroll-point="section-text-e7405c08"><section class="sc-gfrfnr-0 gJxpwG custom-css-style-first-section custom-css-section-e7405c08" data-cy="section-background-wrapper" style="background-color:#fff"><div class="sc-gfrfnr-2 deOrHQ"><div class="sc-1oxti4r-0 ixGbOy"><img data-cy="section-background-image" role="presentation" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/HcU/sWb17AUkqGgp.png" alt="" class="sc-itprxg-0 UZqcu"/></div><div class="sc-gfrfnr-1 iVfIXi custom-css-style-first-section-background"></div></div><div class="sc-18h7are-0 ebVyJP"><div role="presentation" inert="true" aria-hidden="true" class="sc-lqj8ks-0 hfKXfE"><div style="font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;color:#fff;background-color:rgba(0, 0, 0, 0)" class="sc-3k6t01-0 jLGbJs"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-0 dYPHZW"><div class="sc-1aabq8s-0 sc-1aabq8s-1 kJLltb"><div class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></div><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 kpwRdG"><nav><ul class="sc-1aabq8s-2 sc-1aabq8s-3 sc-1xewqye-0 hdTF"><li class="sc-1aabq8s-4 kcKagb"><div class="sc-ir8rf5-0 dPcHAE">Company website</div></li><li class="sc-1aabq8s-4 kcKagb"><div title="instagram" class="sc-7glywv-0 hlNgLl"><span class="sc-1rd450u-0 bIScAX"><svg width="18" height="18" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></div></li></ul></nav></div></div><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-1 ciZwhu"><div class="sc-1aabq8s-0 sc-1aabq8s-1 sc-1hkznj2-0 cghDST"><div class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></div><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 sc-1hkznj2-1 guEbMs"><div class="sc-s03za1-0 jmbcoz sc-1tu9xny-3 cAzrSG"><span class="sc-1rd450u-0 bIScAX"><svg height="12" width="18" viewBox="0 0 18 12"><path d="M0 12h18v-2H0v2Zm0-5h18V5H0v2Zm0-7v2h18V0H0Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg></span></div></div></div></div></div></div></div><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 guycoN"><div style="color:#fff;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><p class="sc-1we8l0o-2 dPLHJJ"></p></div></div></div></div></div></section></div><div data-scroll-point="section-jobs-c88dea0d"><section class="sc-gfrfnr-0 gQRcOO custom-css-section-c88dea0d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 bSaXtg"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 guycoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 bEnYHY"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h2 data-slate-node="element" class="sc-1npqnwg-2 sc-1npqnwg-3 eFVUhY slate-h2"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Current openings</span></span></span></h2></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div><div class="sc-4j8eof-0 dPfocN"><div data-testid="offer-list-grid" class="sc-1mxcttb-0 dWcJRW"><div class="sc-4j8eof-1 jFfmvQ"><div class="sc-4j8eof-2 iOxTuT"><output class="sc-1mxcttb-2 fDKnQQ"><div class="sc-1dywz0m-0 exQcZ"><div class="sc-1qe5ahw-0 ffHrMJ"><div class="sc-18rtkup-1 hhapWv"><table class="sc-18rtkup-0 bJoAoi"><thead><tr><th style="width:50%">Job title</th><th style="width:50%">Work model</th><th></th></tr></thead><tbody><tr><td><a href="/o/copywriter-talen-pool" class="sc-18rtkup-2 bqJcqI">Copywriter Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/copywriter-talen-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/design-talent-pool" class="sc-18rtkup-2 bqJcqI">Design Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/design-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/developer-talent-pool" class="sc-18rtkup-2 bqJcqI">Developer Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/developer-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/project-manager-talent-pool" class="sc-18rtkup-2 bqJcqI">Project Manager Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/project-manager-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr></tbody></table></div></div></div><div class="sc-1dywz0m-1 gcbsVn"><div class="sc-465zle-0 brHqfD"><div class="sc-465zle-1 fTGeMR"><a href="/o/copywriter-talen-pool" class="sc-465zle-2 bCpqiX">Copywriter Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/copywriter-talen-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/design-talent-pool" class="sc-465zle-2 bCpqiX">Design Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/design-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/developer-talent-pool" class="sc-465zle-2 bCpqiX">Developer Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/developer-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/project-manager-talent-pool" class="sc-465zle-2 bCpqiX">Project Manager Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/project-manager-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div></div></div></output></div></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-image-fb8d4333"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-fb8d4333" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 gZDsxt"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 sc-bq9z91-0 iOQKaL"><div class="sc-1dj1hqi-2 hPupHS"><div class="sc-pelm1o-0 hYJywo"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Our Philosophy</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We have a lot of fun together, something we consider to be really important. The creative process isn’t easy, but enjoying the journey is something we do well. We love what we do, and we think you’ll love working with us.</span></span></span></p></div></div></div></div></div></div><div class="sc-1dj1hqi-2 fXdQP"><div class="sc-11gkm9w-0 lcroFG"><div class="sc-11gkm9w-1 YAzbZ"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img class="sc-146moy0-0 cTyKMn" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/ImA/Z18mPRgadPTx.jpeg" alt="some text" loading="lazy" width="1080" height="1080"/></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-image-c316b05d"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-c316b05d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 kdUgoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 sc-bq9z91-0 OebVS"><div class="sc-1dj1hqi-2 hPupHS"><div class="sc-pelm1o-0 hYJywo"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Our Clients</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">From powerhouses like the Brooklyn Navy Yard, Sesame Workshop, Vital Strategies, and Columbia University, to global movers and shakers like The American Cancer Society, United Nations, the International Rescue Committee, UNICEF, and Women’s Refugee Commission, we’ve worked together to solve some big problems and increase their impact.</span></span></span></p></div></div></div></div></div></div><div class="sc-1dj1hqi-2 fXdQP"><div class="sc-11gkm9w-0 lcroFG"><div class="sc-11gkm9w-1 YAzbZ"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img class="sc-146moy0-0 cTyKMn" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/ImE/pqy0lEe95RqO.jpeg" alt="some text" loading="lazy" width="1080" height="1080"/></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-text-f4523764"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-f4523764" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 hacApq"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1we8l0o-0 iZuBTr"><article class="sc-1we8l0o-1 kNKRnF"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="z" data-slate-length="0">﻿</span></span></span><a data-slate-node="element" data-slate-inline="true" href="/" target="_self" data-link="{&quot;target&quot;:&quot;_self&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;/&quot;}" class="sc-5egf6r-0 cPMqMQ"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="z" data-slate-length="0">﻿</span></span></span></a><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Join a team of kind, curious, and empathetic individuals</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Radish Lab is a creative agency that believes that good design can help solve big challenges. We partner with organizations that are looking to create greater impact in their work and the world around them.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We believe good design is clear, simple, and engaging. And we believe that good design has the power to move you.We focus on helping social change projects and organizations tell compelling digital stories, deeply engage their audiences, and apply smart creative and technical solutions to some pretty impressive challenges.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">With offices in Brooklyn and Berlin, we love helping our clients create and tell compelling visual stories. </span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Radish Lab is also a certified B Corporation, which means we’re held accountable for meeting the highest standards of overall social and environmental performance, transparency and accountability.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="n" data-slate-length="0">﻿<br/></span></span></span></p></div></div></article></div></div></div></div></div></div></section></div><div data-scroll-point="section-gallery-6808b50d"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-6808b50d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 dLnXab"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 jEioAK"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 ipivQc"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">SELECTED CLIENTS</span></span></span></p><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We partner with organizations, activists and optimists. Here’s a handful we’ve already helped.</span></span></span></h3></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 ebMZHP"><div width="12" class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-1 iozrWS"><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilg/KFkAhPsAE6m7.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilk/lVkUsYEyvKky.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilo/S5EkxjRNYf4U.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ils/UcXAqrsyzCFC.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div></div></div><div width="12" class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-1 iozrWS"><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilw/5vZK251ADpLK.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il0/mJUUpYFqt7ny.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il4/J3g5SeRl41JZ.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il8/pXhL2Ip7Ng1z.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div></div></div></div><div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-map-cb09dc8f"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-cb09dc8f" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 kdUgoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 bEnYHY"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 ipivQc"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">OUR OFFICE</span></span></span></p><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Brooklyn – DUMBO</span></span></span></h3></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 hohQBp"><div class="sc-1dj1hqi-2 dvhjIe"><div style="width:100%;min-height:400px;position:relative"></div></div></div></div></div></div></div></div></div></div></section></div><div class="sc-ax9y9i-0 jbcdEK"></div></main><div data-cy="brand-wrapper-section" class="sc-1ktojtq-0 beiMHd"><a href="https://recruitee.com" target="_blank" rel="noreferrer noopenner" aria-label="Hiring with Recruitee" class="sc-1ktojtq-1 eovEqQ"><svg width="241" height="24" viewBox="0 0 241 24" fill="none"><path fill-rule="evenodd" clip-rule="evenodd" d="M121.51 9.08403C121.485 9.08403 121.46 9.08469 121.435 9.08493C119.658 3.80365 114.669 0 108.792 0C102.914 0 97.9245 3.80438 96.1478 9.08648C91.9409 9.19007 88.5625 12.6349 88.5625 16.8693C88.5625 19.0446 89.4544 21.0112 90.8919 22.4237C91.0503 22.5794 91.3 22.5947 91.475 22.4578C91.6655 22.309 91.8748 22.1555 92.1031 22.0014C92.8412 21.4518 93.8535 20.9681 94.7804 20.6317C94.9048 20.5882 95.4997 20.264 95.1679 19.3905C94.3151 18.5164 93.6697 17.1028 93.6697 15.7125C93.6697 13.5824 95.0765 12.4652 96.7245 12.4652C98.3699 12.4652 99.7851 13.5824 99.7851 15.7125C99.7851 17.0983 99.1371 18.5061 98.2862 19.3801H98.2914C97.9674 20.3704 98.4891 20.6063 98.5701 20.6317C98.857 20.727 99.1495 20.8358 99.4388 20.9557C99.5856 21.0166 99.6222 21.2094 99.5079 21.3197C98.7283 22.0729 98.2735 23.0327 98.0347 23.7028C97.9565 23.9223 98.227 24.0979 98.3967 23.9383C98.9716 23.3983 99.7391 22.7543 100.705 22.1024C101.974 21.1571 103.715 20.3252 105.31 19.7465C105.524 19.6718 106.547 19.1141 105.976 17.6118C104.509 16.1084 103.399 13.6771 103.399 11.2858C103.399 7.62214 105.819 5.70046 108.653 5.70046C111.483 5.70046 113.918 7.62214 113.918 11.2858C113.918 13.6692 112.803 16.0906 111.34 17.5939H111.348C110.791 19.297 111.688 19.703 111.828 19.7465C113.453 20.2863 115.183 21.0737 116.465 21.986C117.538 22.6469 118.404 23.3224 119.071 23.9113C119.243 24.0636 119.504 23.8864 119.427 23.6697C119.19 23.0021 118.723 22.0192 117.921 21.2592C117.805 21.1494 117.841 20.9569 117.988 20.8938C118.234 20.7878 118.481 20.6904 118.722 20.6028C118.847 20.5592 119.444 20.2339 119.111 19.3576C118.255 18.4806 117.608 17.0623 117.608 15.6675C117.608 13.5303 119.019 12.4092 120.672 12.4092C122.323 12.4092 123.743 13.5303 123.743 15.6675C123.743 17.0577 123.093 18.4701 122.239 19.3471H122.245C121.92 20.3406 122.443 20.5774 122.524 20.6028C123.884 21.0545 125.37 21.8032 126.029 22.6379C126.187 22.8377 126.481 22.8633 126.671 22.6944C128.277 21.2682 129.29 19.1872 129.29 16.8693C129.29 12.5696 125.807 9.08403 121.51 9.08403Z" fill="#1999E3"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M144.982 8.29481C144.982 9.17907 144.835 9.97335 144.532 10.653C143.959 10.5875 143.321 10.5383 142.928 10.5383C142.331 10.5383 141.504 10.653 140.973 10.8987C140.351 11.1853 139.941 11.7339 139.941 12.8803V21.1096C139.18 21.4782 138.297 21.6255 137.29 21.6255V11.693C137.29 10.1126 137.904 9.29375 139.303 8.72875C140.4 8.28657 141.799 8.0573 142.896 8.0573C143.55 8.0573 144.336 8.13913 144.982 8.29481Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M154.786 13.7155C155.654 13.7155 155.891 13.3388 155.891 12.7738C155.891 11.2917 154.287 10.3746 152.519 10.3746C150.49 10.3746 148.894 11.5784 148.501 13.7155H154.786ZM152.912 21.6255C148.493 21.6255 145.793 18.8742 145.793 14.8456C145.793 10.8414 148.452 8.05731 152.536 8.05731C155.997 8.05731 158.477 10.0553 158.477 13.3142C158.477 15.2386 157.609 15.8117 155.572 15.8117H148.485C148.87 17.9981 150.547 19.2099 153.019 19.2099C154.238 19.2099 155.523 18.9152 156.415 18.6204C156.734 19.2837 156.865 20.0616 156.865 20.9295C155.76 21.3225 154.377 21.6255 152.912 21.6255Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M160.187 14.8456C160.187 10.8496 162.904 8.05731 167.306 8.05731C168.755 8.05731 170.121 8.36027 171.169 8.72876C171.169 9.59672 171.038 10.3582 170.727 11.0133C169.876 10.7186 168.583 10.4565 167.478 10.4565C164.622 10.4565 162.846 12.1924 162.846 14.8456C162.846 17.4985 164.63 19.1772 167.429 19.1772C168.624 19.1772 169.917 18.8742 170.809 18.5713C171.112 19.2509 171.259 20.0452 171.259 20.9295C170.154 21.3225 168.771 21.6255 167.315 21.6255C162.904 21.6255 160.187 18.8415 160.187 14.8456Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M181.578 8.29482C181.578 9.17908 181.431 9.97336 181.128 10.653C180.555 10.5875 179.917 10.5384 179.524 10.5384C178.927 10.5384 178.1 10.653 177.568 10.8987C176.947 11.1853 176.537 11.7339 176.537 12.8803V21.1096C175.776 21.4782 174.892 21.6255 173.885 21.6255V11.693C173.885 10.1126 174.5 9.29376 175.899 8.72876C176.995 8.28659 178.395 8.05731 179.491 8.05731C180.146 8.05731 180.931 8.13914 181.578 8.29482Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M186.112 15.5825C186.112 17.6377 187.225 19.1854 189.336 19.1854C189.68 19.1854 190.539 19.1444 191.243 18.8579C191.987 18.5548 192.249 18.0799 192.249 17.3675V8.57317C193.01 8.20468 193.894 8.05731 194.9 8.05731V17.9899C194.9 19.5702 194.262 20.4137 192.887 20.9541C191.807 21.3799 190.236 21.6255 189.099 21.6255C185.629 21.6255 183.461 19.341 183.461 15.7954V8.57317C184.221 8.20468 185.105 8.05731 186.112 8.05731V15.5825Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M201.104 21.1096C200.342 21.4782 199.458 21.6255 198.452 21.6255V8.57314C199.213 8.20465 200.097 8.05729 201.104 8.05729V21.1096ZM201.529 4.11866C201.529 5.08492 200.752 5.86282 199.786 5.86282C198.821 5.86282 198.043 5.08492 198.043 4.11866C198.043 3.15241 198.821 2.37451 199.786 2.37451C200.752 2.37451 201.529 3.15241 201.529 4.11866Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M208.288 10.7267V17.0073C208.288 18.866 209.532 19.1772 211.815 19.1772C211.815 20.0697 211.684 20.8558 211.357 21.5273C211.005 21.6009 210.768 21.6255 210.391 21.6255C209.008 21.6255 206.913 21.298 206.063 19.4392C205.677 18.604 205.637 17.6459 205.637 16.6142V10.7267H203.288C203.288 9.80145 203.419 8.99894 203.754 8.30296H205.637V4.60176C206.397 4.23327 207.281 4.08591 208.288 4.08591V8.30296H211.897C211.897 9.22007 211.758 10.0306 211.422 10.7267H208.288Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M222.347 13.7155C223.215 13.7155 223.453 13.3388 223.453 12.7738C223.453 11.2917 221.849 10.3746 220.081 10.3746C218.051 10.3746 216.456 11.5784 216.063 13.7155H222.347ZM220.474 21.6255C216.055 21.6255 213.355 18.8742 213.355 14.8456C213.355 10.8414 216.014 8.05731 220.097 8.05731C223.558 8.05731 226.038 10.0553 226.038 13.3142C226.038 15.2386 225.17 15.8117 223.133 15.8117H216.047C216.431 17.9981 218.108 19.2099 220.58 19.2099C221.799 19.2099 223.084 18.9152 223.976 18.6204C224.295 19.2837 224.426 20.0616 224.426 20.9295C223.321 21.3225 221.938 21.6255 220.474 21.6255Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M236.75 13.7155C237.618 13.7155 237.855 13.3388 237.855 12.7738C237.855 11.2917 236.251 10.3746 234.483 10.3746C232.454 10.3746 230.858 11.5784 230.465 13.7155H236.75ZM234.876 21.6255C230.457 21.6255 227.757 18.8742 227.757 14.8456C227.757 10.8414 230.416 8.05731 234.499 8.05731C237.961 8.05731 240.441 10.0553 240.441 13.3142C240.441 15.2386 239.573 15.8117 237.535 15.8117H230.449C230.833 17.9981 232.511 19.2099 234.982 19.2099C236.202 19.2099 237.486 18.9152 238.378 18.6204C238.698 19.2837 238.829 20.0616 238.829 20.9295C237.723 21.3225 236.341 21.6255 234.876 21.6255Z" fill="#37474F"></path><path d="M9 20V8.72656H7.59375V13.6016H1.40625V8.72656H0V20H1.40625V14.8672H7.59375V20H9Z" fill="#37474F"></path><path d="M12.4062 9.95312C12.9219 9.95312 13.3438 9.53125 13.3438 9.01562C13.3438 8.5 12.9219 8.07812 12.4062 8.07812C11.8906 8.07812 11.4688 8.5 11.4688 9.01562C11.4688 9.53125 11.8906 9.95312 12.4062 9.95312ZM11.7344 20H13.0781V11.5781H11.7344V20Z" fill="#37474F"></path><path d="M15.6406 20H16.9844V14.7812C16.9844 13.5938 17.9141 12.7344 19.1953 12.7344C19.4609 12.7344 19.9453 12.7812 20.0547 12.8125V11.4688C19.8828 11.4453 19.6016 11.4297 19.3828 11.4297C18.2656 11.4297 17.2969 12.0078 17.0469 12.8281H16.9219V11.5781H15.6406V20Z" fill="#37474F"></path><path d="M22.4375 9.95312C22.9531 9.95312 23.375 9.53125 23.375 9.01562C23.375 8.5 22.9531 8.07812 22.4375 8.07812C21.9219 8.07812 21.5 8.5 21.5 9.01562C21.5 9.53125 21.9219 9.95312 22.4375 9.95312ZM21.7656 20H23.1094V11.5781H21.7656V20Z" fill="#37474F"></path><path d="M25.6719 20H27.0156V15.0156C27.0156 13.5391 27.8828 12.6406 29.2266 12.6406C30.5703 12.6406 31.2109 13.3594 31.2109 14.875V20H32.5547V14.5469C32.5547 12.5469 31.5 11.4297 29.6094 11.4297C28.3203 11.4297 27.5 11.9766 27.0781 12.9062H26.9531V11.5781H25.6719V20Z" fill="#37474F"></path><path d="M38.4844 23.2344C40.7812 23.2344 42.2344 22.0312 42.2344 20.1484V11.5781H40.9531V12.9141H40.8281C40.3438 12.0078 39.3047 11.4297 38.125 11.4297C35.9609 11.4297 34.5938 13.1406 34.5938 15.6641C34.5938 18.1875 35.9453 19.875 38.125 19.875C39.2812 19.875 40.2344 19.3516 40.7656 18.4219H40.8906V20.0781C40.8906 21.3203 39.9922 22.0625 38.4844 22.0625C37.2734 22.0625 36.5234 21.6172 36.375 20.9297H34.9531C35.1562 22.3203 36.4531 23.2344 38.4844 23.2344ZM38.4219 18.6875C36.8594 18.6875 35.9844 17.5 35.9844 15.6641C35.9844 13.8281 36.8594 12.6406 38.4219 12.6406C39.9766 12.6406 40.9219 13.8281 40.9219 15.6641C40.9219 17.5 39.9844 18.6875 38.4219 18.6875Z" fill="#37474F"></path><path d="M59.875 11.5781H58.5234L56.8672 18.3125H56.7422L54.8594 11.5781H53.5703L51.6875 18.3125H51.5625L49.9062 11.5781H48.5469L50.9062 20H52.2656L54.1406 13.4844H54.2656L56.1484 20H57.5156L59.875 11.5781Z" fill="#37474F"></path><path d="M62.375 9.95312C62.8906 9.95312 63.3125 9.53125 63.3125 9.01562C63.3125 8.5 62.8906 8.07812 62.375 8.07812C61.8594 8.07812 61.4375 8.5 61.4375 9.01562C61.4375 9.53125 61.8594 9.95312 62.375 9.95312ZM61.7031 20H63.0469V11.5781H61.7031V20Z" fill="#37474F"></path><path d="M66.1719 9.39844V11.5781H64.8125V12.7031H66.1719V17.8125C66.1719 19.4219 66.8672 20.0625 68.6016 20.0625C68.8672 20.0625 69.125 20.0312 69.3906 19.9844V18.8516C69.1406 18.875 69.0078 18.8828 68.7656 18.8828C67.8906 18.8828 67.5156 18.4609 67.5156 17.4688V12.7031H69.3906V11.5781H67.5156V9.39844H66.1719Z" fill="#37474F"></path><path d="M71.5 20H72.8438V15.0156C72.8438 13.5938 73.6719 12.6406 75.1797 12.6406C76.4531 12.6406 77.125 13.3828 77.125 14.875V20H78.4688V14.5469C78.4688 12.5703 77.3438 11.4297 75.5625 11.4297C74.2734 11.4297 73.3906 11.9766 72.9688 12.9062H72.8438V8.23438H71.5V20Z" fill="#37474F"></path></svg></a></div></div></div>


<script id="__LOADABLE_REQUIRED_CHUNKS__" type="application/json">[]</script><script id="__LOADABLE_REQUIRED_CHUNKS___ext" type="application/json">{"namedChunks":[]}</script>
<script async data-chunk="main" src="/js/PublicApp/web/main-bundle-ed69588b.js"></script>


  </body>
</html>

+  recorded_at: Tue, 30 Jul 2024 16:28:01 GMT
 - request:
     method: get
     uri: https://radishlab.recruitee.com/api/offers/
@@ -78,7 +78,7 @@ http_interactions:
       Content-Type:
       - application/json; charset=utf-8
       Date:
-      - Thu, 27 Jun 2024 13:37:19 GMT
+      - Tue, 30 Jul 2024 16:28:01 GMT
       Server:
       - Cowboy
       Strict-Transport-Security:
@@ -86,7 +86,7 @@ http_interactions:
       Vary:
       - accept-encoding
       X-Request-Id:
-      - F9zf_e0ifbg-OboCGjjC
+      - F-cKdWLOjKwRk5wBLoTh
       Via:
       - 1.1 google
       Alt-Svc:
@@ -96,11 +96,11 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"offers":[{"state_code":"NY","slug":"copywriter-talen-pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","id":1390320,"options_cv":"required","remote":true,"locations_question_type":"multiple_choice","employment_type_code":"contract","position":45,"requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","salary":{"max":null,"min":null,"period":null,"currency":null},"department":null,"min_hours":null,"published_at":"2023-07-25 17:53:46 UTC","country":"United States","guid":"56ucy","options_phone":"required","category_code":"design","sharing_title":"Copywriter Talent Pool","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_image":null,"sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","note":null,"postal_code":null,"street":null}},"country_code":"US","note":null,"postal_code":null,"street":null,"state_code":"NY"}],"company_name":"Radish Lab","location_question_visible":false,"postal_code":null,"tags":[],"max_hours":null,"options_cover_letter":"optional","cover_image":null,"locations_question":"What is your preferred work location?","updated_at":"2024-06-05 19:21:54 UTC","status":"published","mailbox_email":"job.56ucy@radishlab.recruitee.com","state_name":"New York","city":"BROOKLYN","careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool","location":"Remote job","country_code":"US","title":"Copywriter Talent Pool","close_at":null,"locations_question_required":true,"careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"experience_code":"mid_level","on_site":false,"sharing_image":null,"created_at":"2023-07-25 16:04:54 UTC","options_photo":"optional","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","hybrid":false,"education_code":"bachelor_degree"},{"state_code":"NY","slug":"project-manager-talent-pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","id":1357326,"options_cv":"required","remote":true,"locations_question_type":"multiple_choice","employment_type_code":"fulltime","position":43,"requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"department":"Strategy & Project Management","min_hours":null,"published_at":"2023-06-21 22:14:02 UTC","country":"United States","guid":"u4kva","options_phone":"optional","category_code":"design","sharing_title":"Project Manager Talent Pool","translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_image":null,"sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","note":null,"postal_code":"11201","street":"20 Jay Street"}},"country_code":"US","note":null,"postal_code":"11201","street":"20 Jay Street","state_code":"NY"}],"company_name":"Radish Lab","location_question_visible":false,"postal_code":"11201","tags":[],"max_hours":null,"options_cover_letter":"optional","cover_image":null,"locations_question":"What is your preferred work location?","updated_at":"2024-06-03 19:24:57 UTC","status":"published","mailbox_email":"job.u4kva@radishlab.recruitee.com","state_name":"New York","city":"Brooklyn","careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool","location":"Remote job","country_code":"US","title":"Project Manager Talent Pool","close_at":null,"locations_question_required":true,"careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"experience_code":"mid_level","on_site":false,"sharing_image":null,"created_at":"2023-06-21 22:11:24 UTC","options_photo":"off","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","hybrid":false,"education_code":"professional"},{"state_code":"NY","slug":"developer-talent-pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","id":1333509,"options_cv":"required","remote":true,"locations_question_type":"multiple_choice","employment_type_code":"contract","position":42,"requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","salary":{"max":null,"min":null,"period":null,"currency":null},"department":"Development","min_hours":null,"published_at":"2023-07-24 19:56:03 UTC","country":"United States","guid":"pwpku","options_phone":"required","category_code":"technical","sharing_title":"Developer Talent Pool","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_image":null,"sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","note":null,"postal_code":null,"street":null}},"country_code":"US","note":null,"postal_code":null,"street":null,"state_code":"NY"}],"company_name":"Radish Lab","location_question_visible":false,"postal_code":null,"tags":[],"max_hours":null,"options_cover_letter":"optional","cover_image":null,"locations_question":"What is your preferred work location?","updated_at":"2024-05-28 14:00:43 UTC","status":"published","mailbox_email":"job.pwpku@radishlab.recruitee.com","state_name":"New York","city":"New York","careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool","location":"Remote job","country_code":"US","title":"Developer Talent Pool","close_at":null,"locations_question_required":true,"careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"experience_code":"mid_level","on_site":false,"sharing_image":null,"created_at":"2023-05-31 13:38:00 UTC","options_photo":"optional","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","hybrid":false,"education_code":"bachelor_degree"},{"state_code":"NY","slug":"design-talent-pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","id":1333465,"options_cv":"required","remote":true,"locations_question_type":"multiple_choice","employment_type_code":"contract","position":41,"requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","salary":{"max":null,"min":null,"period":null,"currency":null},"department":"Design","min_hours":null,"published_at":"2023-07-24 19:56:30 UTC","country":"United States","guid":"2ccy3","options_phone":"required","category_code":"design","sharing_title":"Design Talent Pool","translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_image":null,"sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","note":null,"postal_code":null,"street":null}},"country_code":"US","note":null,"postal_code":null,"street":null,"state_code":"NY"}],"company_name":"Radish Lab","location_question_visible":false,"postal_code":null,"tags":[],"max_hours":null,"options_cover_letter":"optional","cover_image":null,"locations_question":"What is your preferred work location?","updated_at":"2024-06-06 15:41:35 UTC","status":"published","mailbox_email":"job.2ccy3@radishlab.recruitee.com","state_name":"New York","city":"New York","careers_url":"https://radishlab.recruitee.com/o/design-talent-pool","location":"Remote job","country_code":"US","title":"Design Talent Pool","close_at":null,"locations_question_required":true,"careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"experience_code":"mid_level","on_site":false,"sharing_image":null,"created_at":"2023-05-31 13:19:38 UTC","options_photo":"optional","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","hybrid":false,"education_code":"bachelor_degree"}]}
-  recorded_at: Thu, 27 Jun 2024 13:37:19 GMT
+        {"offers":[{"slug":"copywriter-talen-pool","company_name":"Radish Lab","id":1390320,"sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","title":"Copywriter Talent Pool","remote":true,"options_photo":"optional","state_name":"New York","locations_question_required":true,"position":45,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":null,"careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_image":null,"sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"employment_type_code":"contract","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-07-25 17:53:46 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","options_phone":"required","location":"Remote job","category_code":"design","updated_at":"2024-07-10 09:55:41 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"tags":[],"locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"postal_code":null,"sharing_title":"Copywriter Talent Pool","status":"published","guid":"56ucy","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":null,"min":null,"period":null,"currency":null},"on_site":false,"sharing_image":null,"city":"BROOKLYN","cover_image":null,"requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","created_at":"2023-07-25 16:04:54 UTC","options_cover_letter":"optional","education_code":"bachelor_degree","locations_question_type":"multiple_choice","mailbox_email":"job.56ucy@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>"},{"slug":"project-manager-talent-pool","company_name":"Radish Lab","id":1357326,"sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","title":"Project Manager Talent Pool","remote":true,"options_photo":"off","state_name":"New York","locations_question_required":true,"position":43,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":"Strategy & Project Management","careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool","translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_image":null,"sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"employment_type_code":"fulltime","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-06-21 22:14:02 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","options_phone":"optional","location":"Remote job","category_code":"design","updated_at":"2024-06-10 18:24:23 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"tags":[],"locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","postal_code":"11201","street":"20 Jay Street","note":null}},"country_code":"US","postal_code":"11201","state_code":"NY","street":"20 Jay Street","note":null}],"postal_code":"11201","sharing_title":"Project Manager Talent Pool","status":"published","guid":"u4kva","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"on_site":false,"sharing_image":null,"city":"Brooklyn","cover_image":null,"requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","created_at":"2023-06-21 22:11:24 UTC","options_cover_letter":"optional","education_code":"professional","locations_question_type":"multiple_choice","mailbox_email":"job.u4kva@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>"},{"slug":"developer-talent-pool","company_name":"Radish Lab","id":1333509,"sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","title":"Developer Talent Pool","remote":true,"options_photo":"optional","state_name":"New York","locations_question_required":true,"position":42,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":"Development","careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_image":null,"sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"employment_type_code":"contract","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-07-24 19:56:03 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","options_phone":"required","location":"Remote job","category_code":"technical","updated_at":"2024-06-30 19:58:06 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"tags":[],"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"postal_code":null,"sharing_title":"Developer Talent Pool","status":"published","guid":"pwpku","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":null,"min":null,"period":null,"currency":null},"on_site":false,"sharing_image":null,"city":"New York","cover_image":null,"requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","created_at":"2023-05-31 13:38:00 UTC","options_cover_letter":"optional","education_code":"bachelor_degree","locations_question_type":"multiple_choice","mailbox_email":"job.pwpku@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>"},{"slug":"design-talent-pool","company_name":"Radish Lab","id":1333465,"sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","title":"Design Talent Pool","remote":true,"options_photo":"optional","state_name":"New York","locations_question_required":true,"position":41,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":"Design","careers_url":"https://radishlab.recruitee.com/o/design-talent-pool","translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_image":null,"sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"employment_type_code":"contract","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-07-24 19:56:30 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","options_phone":"required","location":"Remote job","category_code":"design","updated_at":"2024-07-10 01:26:39 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"tags":[],"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"postal_code":null,"sharing_title":"Design Talent Pool","status":"published","guid":"2ccy3","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":null,"min":null,"period":null,"currency":null},"on_site":false,"sharing_image":null,"city":"New York","cover_image":null,"requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","created_at":"2023-05-31 13:19:38 UTC","options_cover_letter":"optional","education_code":"bachelor_degree","locations_question_type":"multiple_choice","mailbox_email":"job.2ccy3@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>"}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:01 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.radishlab.com/"]}],"limit":1}'
@@ -123,9 +123,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Thu, 27 Jun 2024 13:37:20 GMT
+      - Tue, 30 Jul 2024 16:28:02 GMT
       Etag:
-      - W/"1719495440105"
+      - W/"1722356882421"
       Server:
       - openresty
       X-Cb-Engine:
@@ -141,7 +141,7 @@ http_interactions:
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '16'
+      - '14'
       Content-Length:
       - '539'
       Connection:
@@ -152,6 +152,6 @@ http_interactions:
         Lab","identifier":{"permalink":"radish-lab","image_id":"twahkcz5ajw2iyujvuqc","uuid":"f9940cee-5c3e-4ce2-c124-9b4fc6fb72c6","entity_def_id":"organization","value":"Radish
         Lab"},"linkedin":{"value":"https://www.linkedin.com/company/radish-media-llc"},"short_description":"Radish
         Lab is a full-service interactive creative agency focused on people and projects
-        changing the world.","rank_org":1117568,"website_url":"http://radishlab.com/"}}]}'
-  recorded_at: Thu, 27 Jun 2024 13:37:20 GMT
+        changing the world.","rank_org":1013571,"website_url":"http://radishlab.com/"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:02 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_smartrecruiters.yml b/spec/fixtures/cassettes/create_company_smartrecruiters.yml
index 1fad6956..187fd880 100644
--- a/spec/fixtures/cassettes/create_company_smartrecruiters.yml
+++ b/spec/fixtures/cassettes/create_company_smartrecruiters.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:54 GMT
+      - Tue, 30 Jul 2024 16:28:02 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -27,10 +27,10 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - AWSALB=Id9KkZ+4zJcvMgF2gG1h1JsYeljQlQ/8CP25eLA8VaOy1RBguGx+n6t80XLuPo+sd7ru1GIoe3pEaHZSqXjvHukeL+yl9CclSjLowyB/Bg/pIwsafFEc4rMMPpUw;
-        Expires=Mon, 05 Aug 2024 09:13:54 GMT; Path=/
-      - AWSALBCORS=Id9KkZ+4zJcvMgF2gG1h1JsYeljQlQ/8CP25eLA8VaOy1RBguGx+n6t80XLuPo+sd7ru1GIoe3pEaHZSqXjvHukeL+yl9CclSjLowyB/Bg/pIwsafFEc4rMMPpUw;
-        Expires=Mon, 05 Aug 2024 09:13:54 GMT; Path=/; SameSite=None; Secure
+      - AWSALB=NFJDR82KdLMbWOjfbulBmBn1oYcTFXUZQGhWKe2+2W4qrWxUxY+dX7ctgGY2WnS3CXcpVSmcDJSk+tkC7QNKDXWvHxz5E/o5WukVCplrDtwHaD6G6ZQ4/RanqcQl;
+        Expires=Tue, 06 Aug 2024 16:28:02 GMT; Path=/
+      - AWSALBCORS=NFJDR82KdLMbWOjfbulBmBn1oYcTFXUZQGhWKe2+2W4qrWxUxY+dX7ctgGY2WnS3CXcpVSmcDJSk+tkC7QNKDXWvHxz5E/o5WukVCplrDtwHaD6G6ZQ4/RanqcQl;
+        Expires=Tue, 06 Aug 2024 16:28:02 GMT; Path=/; SameSite=None; Secure
       Dcr-Decision-By:
       - public-posting-api
       Dcr-Processing-Time-Ms:
@@ -40,7 +40,7 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Etag:
-      - W/"c5a9-tmL+EiWr0pgat2hhK4D4zDLHX8s"
+      - W/"98d5-Z9K0gezRb5N1xzbbI8kxhLbIWCk"
       Datacenter:
       - fran
       Strict-Transport-Security:
@@ -54,11 +54,25 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfee23b67459b-LHR
+      - 8ab6b83428629498-LHR
     body:
       encoding: ASCII-8BIT
-      string: '{"offset":0,"limit":100,"totalFound":18,"content":[{"id":"744000003338800","name":"Food
-        Technical Administrator - (12 Month Fixed Term Contract)","uuid":"5646d6c7-574b-4322-b34c-fda5c3d5aeb0","jobAdId":"47bf63d9-ac4e-44c9-9c37-2703577b6e4d","defaultJobAd":true,"refNumber":"000000000578","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T08:51:00.002Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
+      string: '{"offset":0,"limit":100,"totalFound":14,"content":[{"id":"744000003360384","name":"Junior
+        Technical Artworker - (12 Month Fixed Term Contract)","uuid":"d67d464f-923c-4e6c-8a94-55113df4dd68","jobAdId":"862af3c0-0fd6-4041-8bd7-5e1c1a3c8e1b","defaultJobAd":true,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T10:18:30.916Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
+        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
+        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
+        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
+        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
+        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
+        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
+        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
+        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
+        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
+        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
+        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
+        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003360384","language":{"code":"en","label":"English","labelNative":"English
+        (US)"}},{"id":"744000003338800","name":"Food Technical Administrator - (12
+        Month Fixed Term Contract)","uuid":"5646d6c7-574b-4322-b34c-fda5c3d5aeb0","jobAdId":"47bf63d9-ac4e-44c9-9c37-2703577b6e4d","defaultJobAd":true,"refNumber":"000000000578","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T08:51:00.002Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
         Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
         Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
@@ -98,36 +112,6 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"28000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"Tara Abboud"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003335215","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000003218005","name":"Junior Technical Artworker - (12 Month
-        Fixed Term Contract)","uuid":"ac45b3c0-efce-406b-aced-638d8ba90846","jobAdId":"862af3c0-0fd6-4041-8bd7-5e1c1a3c8e1b","defaultJobAd":true,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-27T08:17:24.961Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003218005","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000003217965","name":"Junior Technical Artworker - (12 Month
-        Fixed Term Contract)","uuid":"bd4d1d8c-18e2-428c-bad1-ac75c55524c3","jobAdId":"73a77ffc-84c8-47fc-9655-91ccff9f0c72","defaultJobAd":false,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-27T08:16:39.707Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003217965","language":{"code":"en","label":"English","labelNative":"English
         (US)"}},{"id":"744000002592247","name":"Warehouse Team Leader","uuid":"9430262b-497f-4913-956a-3810227a6aae","jobAdId":"c1e22017-3b58-4d31-996d-4981c990c017","defaultJobAd":true,"refNumber":"REF557M","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T15:58:22.621Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"manufacturing","label":"Manufacturing"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost
         centre","valueId":"6ce5a87a-fa2e-4b22-92a2-1e2d0d33b853","valueLabel":"C6200"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
@@ -151,20 +135,6 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"38200 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"Jamie Tointon"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002567175","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000002516325","name":"QA Manager","uuid":"7b1d3b45-b557-42e1-b559-22866054da08","jobAdId":"980a4b7c-d00d-4000-a8b0-e6779e1e4a22","defaultJobAd":true,"refNumber":"000000000449","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T10:07:36.454Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"88d8ccdd-8459-4264-b8a2-5c8e7edb2197","valueLabel":"Foundations"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"31500 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Joanna Frankowska"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002516325","language":{"code":"en","label":"English","labelNative":"English
         (US)"}},{"id":"744000002509176","name":"Multimedia Content Creator - (6 month
         Fixed Term Contract)","uuid":"a59f7ad5-965a-46b5-b4bb-da0ddd545d84","jobAdId":"9a077858-fda3-416b-b911-f3af7a1cdef3","defaultJobAd":true,"refNumber":"000000000530","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T09:50:33.260Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
@@ -288,35 +258,6 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"95000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"James Carson"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002498002","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000002498534","name":"iOS Developer","uuid":"89fee71a-9098-4a25-8ddf-58cb10134477","jobAdId":"7aa456f0-4296-4fe3-b85f-17fa8d8a2e2d","defaultJobAd":true,"refNumber":"000000000535","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T08:49:31.661Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"b2c16d92-d5b0-4389-abdf-8ac9e31e4935","valueLabel":"Tech
-        Level 2"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"bf5b9a5d-9705-4d96-a909-742091f5f1cc","valueLabel":"Expand"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"f55dbcfa-4ee0-4022-8fba-9ed0fd62508d","valueLabel":"Software
-        Engineering - iOS"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"ea2db863-e8a2-4ecd-a924-e4976ee9059b","valueLabel":"New
-        Markets"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"8896b943-e635-423d-abd1-fe06e3c75f8d","valueLabel":"C8100"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"1cdd887e-233c-4bcb-89b6-f0fccc93ba2c","valueLabel":"Ireland
-        2"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career track","valueId":"328b8cfa-6440-47fa-9283-64be12b08b13","valueLabel":"Software
-        Engineering - Career Track"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"63000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Arjun Sathe"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002498534","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000000526675","name":"Production Supervisor, Nights (R)","uuid":"1404f33e-0743-4890-9055-80d86f199ad3","jobAdId":"54528012-4f1d-4fcf-b711-90513477f221","defaultJobAd":true,"refNumber":"000000000479","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-15T17:26:12.655Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"production","label":"Production"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"d7da8bb0-a7a6-4695-9090-ccd265bfe159","valueLabel":"Default"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f7c15500-dc0f-4ce6-84aa-34f7682262ec","valueLabel":"Operations
-        Fulfilment"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"ceaf9ff8-3d53-47a1-b3dc-fb41178686f3","valueLabel":"C6000"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"39000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Clare Baker"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000000526675","language":{"code":"en","label":"English","labelNative":"English
         (US)"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:13:54 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:02 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_workable.yml b/spec/fixtures/cassettes/create_company_workable.yml
index 82e0beda..9cd0dccf 100644
--- a/spec/fixtures/cassettes/create_company_workable.yml
+++ b/spec/fixtures/cassettes/create_company_workable.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:54 GMT
+      - Tue, 30 Jul 2024 16:26:24 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -33,11 +33,11 @@ http_interactions:
       Access-Control-Allow-Credentials:
       - 'true'
       Set-Cookie:
-      - __cf_bm=WSfSKb8xujbO4WLnTtNrasYGotak7URRHYfIU.oVXSk-1722244434-1.0.1.1-zK1D23InOQNVUlEEtVkO9YPxkE6I6ur2T7PiH0Is3vknfbvp6yhtmSJ2lWXVVxJ1KLSyl02ObhfAxD4AqRJFJw;
-        path=/; expires=Mon, 29-Jul-24 09:43:54 GMT; domain=.workable.com; HttpOnly;
+      - __cf_bm=3DKIv7AtQzlDrxAMtWa5jiEqm_bggCZxf0zFvT5dsnw-1722356784-1.0.1.1-j9V1yH0NJZfIWCdCjTgTF5ukRWwmWygVXUVg8_yIC4HAoicV6Pk5l5hELV3uZqTGwEULoF1BgXDWYEfCaAlxSw;
+        path=/; expires=Tue, 30-Jul-24 16:56:24 GMT; domain=.workable.com; HttpOnly;
         Secure; SameSite=None
-      - wmc=%7B%22cookie_id%22%3A%22c94325e3-7eac-46c8-9f2a-0e86323bd5bb%22%7D; path=/;
-        expires=Sat, 29 Jul 2034 21:13:54 GMT; domain=.workable.com; samesite=none;
+      - wmc=%7B%22cookie_id%22%3A%22a51b2968-10bd-47da-a38e-df6b0bb46455%22%7D; path=/;
+        expires=Mon, 31 Jul 2034 04:26:24 GMT; domain=.workable.com; samesite=none;
         secure
       Expect-Ct:
       - enforce, max-age=86400
@@ -56,16 +56,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabfee33a69651e
+      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b5cddc70bf00
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfee33a69651e-LHR
+      - 8ab6b5cddc70bf00-LHR
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         eyJpZCI6NDM5OTYzLCJ1aWQiOiJhODc0NmIzOC1lOGFhLTQzYTEtYjI4My01ZjhmMjZkYzliMWIiLCJsb2dvIjoiaHR0cHM6Ly93b3JrYWJsZWhyLnMzLmFtYXpvbmF3cy5jb20vdXBsb2Fkcy9hY2NvdW50L2xvZ28vNDM5OTYzL2xvZ28iLCJzdWJkb21haW4iOiJrcm9vIiwibmFtZSI6Iktyb28gQmFuayBMdGQiLCJ1cmwiOiJodHRwczovL2tyb28uY29tLyIsImxhbmd1YWdlcyI6eyJkZWZhdWx0IjoiZW4iLCJvcHRpb25zIjpbeyJuYW1lIjoiZW4iLCJwdWJsaXNoZWQiOnRydWUsImVuYWJsZWQiOnRydWUsInZpc2libGUiOnRydWV9XX0sImRldGFpbHMiOnsib3ZlcnZpZXciOnsiZGVzY3JpcHRpb24iOiI8cD5XZeKAmXJlIG9uIGEgbWlzc2lvbiB0byBidWlsZCB0aGUgd29ybGTigJlzIGdyZWF0ZXN0IHNvY2lhbCBiYW5rLiBXZSBiZWxpZXZlIHRoYXQgYmFua2luZyBuZWVkcyB0byBjaGFuZ2UgZm9yIHRoZSBiZXR0ZXIsIGJlY2F1c2Ugd2hlbiBtb25leSBpcyB1c2VkIGNvcnJlY3RseSwgaXQgY2FuIHRyYW5zZm9ybSBvdXIgZGFpbHkgbGl2ZXMgYW5kIHBvc2l0aXZlbHkgaW1wYWN0IHRoZSBwbGFuZXQuPC9wPiJ9LCJlZW9jIjp7ImRpc2NsYWltZXIiOm51bGx9LCJvZmNjcCI6ZmFsc2UsImdkcHIiOnsidXJsIjoiaHR0cHM6Ly9hcHBseS53b3JrYWJsZS5jb20va3Jvby9nZHByX3BvbGljeSIsInJlcXVlc3RBcHBsaWNhbnRDb25zZW50IjpmYWxzZX0sIm1haWxib3giOnsiZW5hYmxlZCI6ZmFsc2UsInRleHQiOm51bGwsImVtYWlsIjoia3Jvb0Bqb2JzLndvcmthYmxlbWFpbC5jb20ifSwiZ3Vlc3NBdmF0YXIiOmZhbHNlLCJhcHBseVdpdGhMaW5rZWRpbiI6eyJhcHBJZCI6Ijc3c2JkcDMyenJmcTBwIiwicnNjT3JnYW5pemF0aW9uSWQiOiJ1cm46bGk6b3JnYW5pemF0aW9uOjExMDQ1MzA0IiwiYXdsaU9yZ2FuaXphdGlvbklkIjoidXJuOmxpOm9yZ2FuaXphdGlvbjoxMTA0NTMwNCJ9LCJhcHBseVdpdGhJbmRlZWQiOnRydWUsImRlcGFydG1lbnRzUHVibGljTGV2ZWwiOjF9fQ==
-  recorded_at: Mon, 29 Jul 2024 09:13:54 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:24 GMT
 - request:
     method: get
     uri: https://www.workable.com/api/accounts/kroo?details=true
@@ -85,7 +85,7 @@ http_interactions:
       message: Moved Temporarily
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:54 GMT
+      - Tue, 30 Jul 2024 16:26:24 GMT
       Content-Type:
       - text/html
       Content-Length:
@@ -99,8 +99,8 @@ http_interactions:
       Location:
       - https://apply.workable.com/api/v1/widget/accounts/kroo?details=true
       Set-Cookie:
-      - __cf_bm=xH_OnnWuCb.vqofI4Ex1.SIvjPfxgrcirB3W6swVH1I-1722244434-1.0.1.1-cR6JCKWlU2P26OFyCvvKCufwARZTHtK299gEr89hSO2sGJlrQiSnE9Fi7.T37uh028RjfEld9sR78AvXdfkSiA;
-        path=/; expires=Mon, 29-Jul-24 09:43:54 GMT; domain=.workable.com; HttpOnly;
+      - __cf_bm=US6ObDs7PVV8In5E4TVaLGXFsCFPWdeRDemPW54Yjh4-1722356784-1.0.1.1-FY2fd99V90b8YmfTvdm64TRkyn1ifqUjSoJi1YBlEd5G3U0_9XPl5v47oa_5PYF75liYfVIXYe0VxtdrbXamsA;
+        path=/; expires=Tue, 30-Jul-24 16:56:24 GMT; domain=.workable.com; HttpOnly;
         Secure; SameSite=None
       Vary:
       - Accept-Encoding
@@ -111,16 +111,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors https://*.workable.com/; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabfee45dc0885f
+      - frame-ancestors https://*.workable.com/; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b5cf08dc4130
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfee45dc0885f-LHR
+      - 8ab6b5cf08dc4130-LHR
     body:
       encoding: UTF-8
       string: "<html>\r\n<head><title>302 Found</title></head>\r\n<body>\r\n<center><h1>302
         Found</h1></center>\r\n<hr><center>cloudflare</center>\r\n</body>\r\n</html>\r\n"
-  recorded_at: Mon, 29 Jul 2024 09:13:54 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:24 GMT
 - request:
     method: get
     uri: https://apply.workable.com/api/v1/widget/accounts/kroo?details=true
@@ -131,7 +131,7 @@ http_interactions:
       Accept:
       - application/json
       Cookie:
-      - __cf_bm=xH_OnnWuCb.vqofI4Ex1.SIvjPfxgrcirB3W6swVH1I-1722244434-1.0.1.1-cR6JCKWlU2P26OFyCvvKCufwARZTHtK299gEr89hSO2sGJlrQiSnE9Fi7.T37uh028RjfEld9sR78AvXdfkSiA
+      - __cf_bm=US6ObDs7PVV8In5E4TVaLGXFsCFPWdeRDemPW54Yjh4-1722356784-1.0.1.1-FY2fd99V90b8YmfTvdm64TRkyn1ifqUjSoJi1YBlEd5G3U0_9XPl5v47oa_5PYF75liYfVIXYe0VxtdrbXamsA
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       User-Agent:
@@ -142,7 +142,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:54 GMT
+      - Tue, 30 Jul 2024 16:26:24 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -154,8 +154,8 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Set-Cookie:
-      - wmc=%7B%22cookie_id%22%3A%228fb25c32-05b8-47d7-bf93-6759a416e519%22%7D; path=/;
-        expires=Sat, 29 Jul 2034 21:13:54 GMT; domain=.workable.com; samesite=none;
+      - wmc=%7B%22cookie_id%22%3A%223a13e27f-8b71-49bd-be95-da50adedaa7e%22%7D; path=/;
+        expires=Mon, 31 Jul 2034 04:26:24 GMT; domain=.workable.com; samesite=none;
         secure
       Expect-Ct:
       - enforce, max-age=86400
@@ -176,16 +176,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabfee4cd21634c
+      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b5cfaf1a7714
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfee4cd21634c-LHR
+      - 8ab6b5cfaf1a7714-LHR
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         {"name":"Kroo Bank Ltd","description":"<p>We’re on a mission to build the world’s greatest social bank. We believe that banking needs to change for the better. When money is used correctly, it can transform our daily lives and positively impact the planet.</p>","jobs":[{"title":"Compliance Manager","shortcode":"83183A94A5","code":"CM5","employment_type":"Full-time","telecommuting":false,"department":"Risk & Compliance","url":"https://apply.workable.com/j/83183A94A5","shortlink":"https://apply.workable.com/j/83183A94A5","application_url":"https://apply.workable.com/j/83183A94A5/apply","published_on":"2024-07-02","created_at":"2024-07-02","country":"United Kingdom","city":"London","state":"England","education":"","experience":"Mid-Senior level","function":"","industry":"Financial Services","locations":[{"country":"United Kingdom","countryCode":"GB","city":"London","region":"England","hidden":false}],"description":"<p><strong>What We’re All About at Kroo</strong></p><p>Kroo has a big vision. To be the first bank that is both trusted and loved by its customers. We’re helping people take control of their financial future and achieve their goals, whilst making a positive impact on the planet. Here at Kroo, doing what is right is in our DNA. We act with integrity, transparency and honesty. We think big, dream big, and relentlessly pursue our goals. We like to be bold, break new ground, and we never stop learning. But most importantly, we are on this journey together.</p><p></p><p><strong>How you will contribute:</strong></p><p>The Compliance Manager will play a pivotal role in supporting the Compliance function for our rapidly growing, regulated organisation. This position ensures adherence to regulatory requirements, supports policy development, and fosters a customer-centric culture. The Compliance Manager will also be instrumental in enhancing the new compliance frameworks and procedures. Other responsibilities include: \t\t\t</p><p> </p><ul> <li>Compliance Monitoring Program: Compliance Monitoring Program. Ensure effective oversight and management of compliance risks through regular monitoring and assessment.</li> <li>Regulatory Analysis and Implementation: Collaborate with the Head of Compliance to analyse and interpret relevant regulations. Work closely with various teams to implement regulatory requirements efficiently. Stay up-to-date with changes in regulatory environments and ensure compliance strategies are current.</li> <li>Complaints, TCF, and Vulnerable Customers Framework: Support the business with advice to ensure frameworks are effectively addressing customer needs and regulatory requirements.</li> <li>Product Team Collaboration: Partner with the product team to integrate compliance requirements into the development of banking and lending products and services. Ensure that new products and features comply with relevant regulations and industry best practices. Provide guidance and support to the product team on compliance-related matters.</li> <li>Customer-Centric Culture: Promote a customer-centric approach within the compliance function and across the organisation. Ensure that compliance initiatives align with the goal of delivering excellent customer service. Foster a culture of transparency, integrity, and accountability.</li> <li>Policy Development and Improvement: Support the Chief Risk Officer (CRO) and the Head of Compliance in updating and improving existing policies and procedures. Lead the development of new compliance policies and procedures in response to regulatory changes or organisational needs. Ensure all policies and procedures are documented, communicated, and enforced consistently.</li> <li>Additional Responsibilities: Perform other duties as assigned to meet business needs and support the overall compliance function. Participate in compliance training and development initiatives for staff. Represent the compliance function in internal and external meetings as required.</li> <li>Other duties as assigned to meet business needs.</li> </ul><p></p><p>The Kroo is growing and we’d love to hear from you if you’re interested in joining us on our journey!</p><p></p><h3></h3><p><strong>Requirements</strong></p><p><strong>About You</strong></p><p>While not essential, the following experience and qualifications are highly desirable in our ideal candidate for this position:</p><ul> <li>Extensive experience across various facets of the Compliance function, including conduct risk, consumer credit regulations, payments, complaints handling (with expertise in dealing with the Financial Ombudsman Service), Treating Customers Fairly, conflicts of interest, financial promotions, anti-bribery and corruption, data protection, and other related areas (not all are required).</li> <li>Regulatory compliance experience in the banking sector</li> <li>Knowledge of the SMCR.</li> <li>A positive attitude and a strong willingness to learn.</li> <li>Degree qualified in a relevant subject. </li> </ul><p></p><p><strong>About Our Process:</strong></p><p>We can be flexible with the structure of our interview process if someone's circumstances or timescales require it but our general structure is:<br></p><ul> <li>30-minute people screen with our talent acquisition specialist via google hangouts.</li> <li>1-hour technical interview interview via google hangouts.</li> <li>45-minute final interview&nbsp;via google hangouts.<br> </li> </ul><p>Please let us know if you have any specific requirements or need assistance so we can be as accommodating as possible for you.</p><p></p><p><strong>Benefits</strong></p><p><strong>What we offer:</strong></p><p>At our cutting-edge fintech company, we know that attracting and retaining the best talent means offering top-notch benefits that help our employees thrive both in and outside of work. Check out what we currently offer:</p><p></p><ul> <li>Generous holiday time: 25 days annual leave, 8 bank holidays, 1 Kroo bank holiday (June 24th), and 1 day off during the week of your birthday.</li> <li>Personal days: We know that life can be unpredictable, so we offer 3 personal days to use as needed.</li> <li>Employer-sponsored volunteer program: We're passionate about giving back to our community, and we support our employees in doing the same with up to 4 hours per month of employer-sponsored volunteer time.</li> <li>Mental health support: We care about the mental health of our team members and offer access to Spill, our mental health support partner.</li> <li>Workplace pension: We want you to feel secure about your future, so we offer a workplace pension with a 5% employee contribution and a 3% employer top-up.</li> <li>Learning and development: After 1 year of service, you'll have access to £500 from the Kroo Learning Fund to invest in your career development.</li> <li>Top-notch equipment: We provide top-of-the-line equipment necessary for smooth hybrid work, including a MacBook laptop. Additionally, we also offer support in establishing your home office by contributing towards your setup if required.</li> <li>Modern office: When you're in the office, you'll enjoy access to our modern, bustling workspace in Holborn, Central London, which includes a full gym.</li> <li>Cycle to Work scheme: We encourage sustainable transportation with our Cycle to Work scheme.</li> <li>Electric Car scheme: We're committed to reducing our carbon footprint, and our Electric Car scheme makes it easy for our employees to do the same.</li> <li>Enhanced parental leave: We know that family comes first, and we offer an enhanced parental leave policy to support our employees in starting and growing their families.</li> <li>Room for growth: As a fast-paced, high-growth start-up, we're dedicated to providing our employees with room to grow and excel.</li> <li>You get full healthcare for you and your nuclear family via Vitality.</li> </ul><p><br></p><p><strong>Hybrid Working:</strong></p><p>At Kroo Bank, we have a hybrid policy that gives both individuals and teams a lot of freedom when it comes to using the office space to boost productivity. Our London office is a great resource when used effectively. So, employees who can occasionally come to the office are a good fit for how we work right now. Keep in mind that this job involves working from Monday to Friday, with a mix of remote and office work, so you won't need to be on-site all the time.</p><p></p><p><strong>Diversity and Inclusion:</strong></p><p>We wholeheartedly uphold our commitment to fostering a diverse and inclusive workplace. Every employee is highly regarded, respected, and supported without any form of judgement or prejudice. We consider Diversity, Equality, and Inclusion as fundamental pillars guiding our path in all aspects of our bank. We also ensure that reasonable adjustments are made available to all candidates throughout the recruitment process.</p><p></p><p><strong>To all Recruitment Agencies:</strong></p><p>At Kroo Bank, agency resumes are strictly prohibited. Do not submit agency resumes or forward them to our job advertisements or Kroo Bank employees. Be aware that Kroo Bank will not assume any responsibility for fees incurred due to unsolicited resumes.</p><p>To ensure a fair and efficient application process, all candidates are kindly requested to submit their applications directly through the advertised platform. We kindly ask that you refrain from reaching out to the company or its employees via email, LinkedIn, or any other communication channels for inquiries or updates. Please note that any attempts to contact us through these channels will not receive a response. Thank you for your understanding and cooperation. </p><p></p>"},{"title":"Credit Risk Manager","shortcode":"3B41408A3D","code":"","employment_type":"Full-time","telecommuting":true,"department":"Risk & Compliance","url":"https://apply.workable.com/j/3B41408A3D","shortlink":"https://apply.workable.com/j/3B41408A3D","application_url":"https://apply.workable.com/j/3B41408A3D/apply","published_on":"2024-07-12","created_at":"2024-07-12","country":"United Kingdom","city":"London","state":"England","education":"","experience":"Mid-Senior level","function":"","industry":"Financial Services","locations":[{"country":"United Kingdom","countryCode":"GB","city":"London","region":"England","hidden":false}],"description":"<p><strong>What We’re All About at Kroo</strong></p><p>Kroo has a big vision. To be the first bank that is both trusted and loved by its customers. We’re helping people take control of their financial future and achieve their goals, whilst making a positive impact on the planet. Here at Kroo, doing what is right is in our DNA. We act with integrity, transparency and honesty. We think big, dream big, and relentlessly pursue our goals. We like to be bold, break new ground, and we never stop learning. But most importantly, we are on this journey together.</p><p></p><p><strong>How you will contribute:</strong></p><p>As a Credit Risk Manager, you will play a crucial role in ensuring the bank's credit risk is effectively managed and aligned with regulatory requirements. You will be responsible for assessing and monitoring credit risk, developing risk management strategies, and implementing credit policies and procedures. You will work closely with the Risk Management team, Lending Product team, Credit Underwriting team, Finance and other stakeholders to mitigate credit risk and support Kroo bank's growth objectives.</p><p></p><p>The Kroo is growing and we’d love to hear from you if you’re interested in joining us on our journey.</p><p></p><p></p><h3></h3><p><strong>Requirements</strong></p><p><strong>About you</strong></p><p>While not all essential, the following experience is highly desirable in our ideal candidate for this position:</p><p><strong><br><br>Here's what you'll be doing</strong></p><ul> <li>Evaluate and analyse credit risk exposures for various types of lending including overdrafts and personal loans and potentially SME business lending and credit cards in the future.&nbsp;</li> <li>Conduct periodic credit reviews and assessments.&nbsp;&nbsp;</li> <li>Support the finance and risk department in the production of the Internal Capital Adequacy Assessment Process, determining the capital requirements in relation to the bank’s credit exposures.</li> <li>Monitor industry trends and macroeconomic factors to anticipate potential credit risks.</li> <li>Develop and implement credit risk policies and procedures in accordance with regulatory guidelines and internal risk appetite.</li> <li>Review and update credit risk policies and guidelines to adapt to changing market conditions and industry best practices.</li> <li>Ensure compliance with relevant laws, regulations, and reporting requirements related to credit risk management.</li> <li>Establish risk assessment frameworks, methodologies, and models to quantify and mitigate credit risk.</li> <li>Identify and evaluate risk mitigation techniques, such as credit enhancements.</li> <li>Recommend appropriate risk mitigation strategies and actions to senior management.</li> <li>Monitor the bank's credit portfolio and assess portfolio performance against defined risk metrics and benchmarks.</li> <li>Identify and report key credit risk indicators and trends to senior management and relevant committees.</li> <li>Conduct portfolio stress testing and scenario analysis to assess potential impact on credit risk exposure.</li> <li>Prepare regular credit risk reports, including risk dashboards, key risk indicators, and management reports for internal stakeholders.</li> <li>Present credit risk assessment findings and recommendations to senior management and relevant committees.</li> <li>Support Finance in reporting on non-performing advances and forbearance.</li> <li>Collaborate with internal and external auditors, regulators, and rating agencies during credit risk audits and examinations.</li> </ul><p></p><p><strong>Here’s what we are looking for ideally:&nbsp;</strong></p><ul> <li>Bachelor's degree in finance, economics or a related field.&nbsp;</li> <li>5 years of experience in consumer credit risk management within the banking or financial services industry, preferably in a challenger bank or fintech environment.</li> <li>Strong understanding of credit risk assessment, credit analysis, and lending practices.</li> <li>Familiarity with regulatory requirements and best practices related to credit risk management.</li> <li>Proficiency in using risk management tools and software.</li> <li>Excellent analytical and problem-solving skills with the ability to interpret complex data.</li> <li>Strong written and verbal communication skills, with the ability to present information effectively to diverse audiences.</li> <li>Ability to work collaboratively in a team environment and build relationships with key stakeholders.</li> </ul><p><br><br></p><p><strong>About Our Process:</strong></p><p>We can be flexible with the structure of our interview process if someone's circumstances or timescales require it but our general structure is:</p><p></p><ul> <li>People screen interview - 30 mins</li> <li>Technical interview with the hiring manager - 45 mins</li> <li>Head of division interview - 45 mins&nbsp;</li> </ul><p></p><p>Please let us know if you have any specific requirements or need assistance so we can be as accommodating as possible for you.</p><p></p><p><strong>Benefits</strong></p><p><strong>What we offer:</strong></p><p>At our cutting-edge fintech company, we know that attracting and retaining the best talent means offering top-notch benefits that help our employees thrive both in and outside of work. Check out what we currently offer:</p><p></p><ul> <li>Generous holiday time: 25 days annual leave, 8 bank holidays, 1 Kroo bank holiday (June 24th), and 1 day off during the week of your birthday.</li> <li>Personal days: We know that life can be unpredictable, so we offer 3 personal days to use as needed.</li> <li>Employer-sponsored volunteer program: We're passionate about giving back to our community, and we support our employees in doing the same with up to 4 hours per month of employer-sponsored volunteer time.</li> <li>Mental health support: We care about the mental health of our team members and offer access to Spill, our mental health support partner.</li> <li>Workplace pension: We want you to feel secure about your future, so we offer a workplace pension with a 5% employee contribution and a 3% employer top-up.</li> <li>Learning and development: After 1 year of service, you'll have access to £500 from the Kroo Learning Fund to invest in your career development.</li> <li>Top-notch equipment: We provide top-of-the-line equipment necessary for smooth hybrid work, including a MacBook laptop. Additionally, we also offer support in establishing your home office by contributing towards your setup if required.</li> <li>Modern office: When you're in the office, you'll enjoy access to our modern, bustling workspace in Holborn, Central London, which includes a full gym.</li> <li>Cycle to Work scheme: We encourage sustainable transportation with our Cycle to Work scheme.</li> <li>Electric Car scheme: We're committed to reducing our carbon footprint, and our Electric Car scheme makes it easy for our employees to do the same.</li> <li>Enhanced parental leave: We know that family comes first, and we offer an enhanced parental leave policy to support our employees in starting and growing their families.</li> <li>Room for growth: As a fast-paced, high-growth start-up, we're dedicated to providing our employees with room to grow and excel.</li> <li>You get full healthcare for you and your nuclear family via Vitality.</li> </ul><p><br></p><p><strong>Hybrid Working:</strong></p><p>At Kroo Bank, we have a hybrid policy that gives both individuals and teams a lot of freedom when it comes to using the office space to boost productivity. Our London office is a great resource when used effectively. So, employees who can occasionally come to the office are a good fit for how we work right now. Keep in mind that this job involves working from Monday to Friday, with a mix of remote and office work, so you won't need to be on-site all the time.</p><p></p><p><strong>Diversity and Inclusion:</strong></p><p>We wholeheartedly uphold our commitment to fostering a diverse and inclusive workplace. Every employee is highly regarded, respected, and supported without any form of judgement or prejudice. We consider Diversity, Equality, and Inclusion as fundamental pillars guiding our path in all aspects of our bank. We also ensure that reasonable adjustments are made available to all candidates throughout the recruitment process.</p><p></p><p><strong>To all Recruitment Agencies:</strong></p><p>At Kroo Bank, agency resumes are strictly prohibited. Do not submit agency resumes or forward them to our job advertisements or Kroo Bank employees. Be aware that Kroo Bank will not assume any responsibility for fees incurred due to unsolicited resumes.</p><p>To ensure a fair and efficient application process, all candidates are kindly requested to submit their applications directly through the advertised platform. We kindly ask that you refrain from reaching out to the company or its employees via email, LinkedIn, or any other communication channels for inquiries or updates. Please note that any attempts to contact us through these channels will not receive a response. Thank you for your understanding and cooperation. </p><p></p>"},{"title":"Credit Risk Specialist","shortcode":"2326F61C35","code":"","employment_type":"Full-time","telecommuting":true,"department":"Risk & Compliance","url":"https://apply.workable.com/j/2326F61C35","shortlink":"https://apply.workable.com/j/2326F61C35","application_url":"https://apply.workable.com/j/2326F61C35/apply","published_on":"2024-07-12","created_at":"2024-07-12","country":"United Kingdom","city":"London","state":"England","education":"","experience":"Mid-Senior level","function":"","industry":"Financial Services","locations":[{"country":"United Kingdom","countryCode":"GB","city":"London","region":"England","hidden":false}],"description":"<p><strong>What We’re All About at Kroo</strong></p><p>Kroo has a big vision. To be the first bank that is both trusted and loved by its customers. We’re helping people take control of their financial future and achieve their goals, whilst making a positive impact on the planet. Here at Kroo, doing what is right is in our DNA. We act with integrity, transparency and honesty. We think big, dream big, and relentlessly pursue our goals. We like to be bold, break new ground, and we never stop learning. But most importantly, we are on this journey together.</p><p></p><p><strong>How you will contribute:</strong></p><p>As a Credit Risk Specialist, I will play a crucial role in effectively managing the bank's credit risk in alignment with regulatory requirements. My responsibilities will include assessing and monitoring credit risk, developing risk management strategies, and implementing credit policies and procedures. Collaborating closely with the Risk Management team, Lending Product team, Credit Underwriting team, Finance, and other stakeholders, I will work to mitigate credit risk and support Kroo bank's growth objectives.</p><p></p><p>The Kroo is growing and we’d love to hear from you if you’re interested in joining us on our journey.</p><p></p><p></p><h3></h3><p><strong>Requirements</strong></p><p><strong>About you</strong></p><p>While not all essential, the following experience is highly desirable in our ideal candidate for this position:</p><p><strong><br><br>Here's what you'll be doing</strong></p><ul> <li>Evaluate and analyse credit risk exposures for various types of lending including overdrafts and personal loans and potentially SME business lending and credit cards in the future.&nbsp;</li> <li>Conduct periodic credit reviews and assessments.&nbsp;&nbsp;</li> <li>Support the finance and risk department in the production of the Internal Capital Adequacy Assessment Process, determining the capital requirements in relation to the bank’s credit exposures.</li> <li>Monitor industry trends and macroeconomic factors to anticipate potential credit risks.</li> <li>Develop and implement credit risk policies and procedures in accordance with regulatory guidelines and internal risk appetite.</li> <li>Review and update credit risk policies and guidelines to adapt to changing market conditions and industry best practices.</li> <li>Ensure compliance with relevant laws, regulations, and reporting requirements related to credit risk management.</li> <li>Establish risk assessment frameworks, methodologies, and models to quantify and mitigate credit risk.</li> <li>Identify and evaluate risk mitigation techniques, such as credit enhancements.</li> <li>Recommend appropriate risk mitigation strategies and actions to senior management.</li> <li>Monitor the bank's credit portfolio and assess portfolio performance against defined risk metrics and benchmarks.</li> <li>Identify and report key credit risk indicators and trends to senior management and relevant committees.</li> <li>Conduct portfolio stress testing and scenario analysis to assess potential impact on credit risk exposure.</li> <li>Prepare regular credit risk reports, including risk dashboards, key risk indicators, and management reports for internal stakeholders.</li> <li>Present credit risk assessment findings and recommendations to senior management and relevant committees.</li> <li>Support Finance in reporting on non-performing advances and forbearance.</li> <li>Collaborate with internal and external auditors, regulators, and rating agencies during credit risk audits and examinations.</li> </ul><p></p><p><strong>Here’s what we are looking for ideally:&nbsp;</strong></p><ul> <li>Bachelor's degree in finance, economics or a related field.&nbsp;</li> <li>3 years of experience in consumer credit risk management within the banking or financial services industry, preferably in a challenger bank or fintech environment.</li> <li>Strong understanding of credit risk assessment, credit analysis, and lending practices.</li> <li>Familiarity with regulatory requirements and best practices related to credit risk management.</li> <li>Proficiency in using risk management tools and software.</li> <li>Excellent analytical and problem-solving skills with the ability to interpret complex data.</li> <li>Strong written and verbal communication skills, with the ability to present information effectively to diverse audiences.</li> <li>Ability to work collaboratively in a team environment and build relationships with key stakeholders.</li> </ul><p><br><br></p><p><strong>About Our Process:</strong></p><p>We can be flexible with the structure of our interview process if someone's circumstances or timescales require it but our general structure is:</p><p></p><ul> <li>People screen interview - 30 mins</li> <li>Technical interview with the hiring manager - 45 mins</li> <li>Head of division interview - 45 mins&nbsp;</li> </ul><p></p><p>Please let us know if you have any specific requirements or need assistance so we can be as accommodating as possible for you.</p><p></p><p><strong>Benefits</strong></p><p><strong>What we offer:</strong></p><p>At our cutting-edge fintech company, we know that attracting and retaining the best talent means offering top-notch benefits that help our employees thrive both in and outside of work. Check out what we currently offer:</p><p></p><ul> <li>Generous holiday time: 25 days annual leave, 8 bank holidays, 1 Kroo bank holiday (June 24th), and 1 day off during the week of your birthday.</li> <li>Personal days: We know that life can be unpredictable, so we offer 3 personal days to use as needed.</li> <li>Employer-sponsored volunteer program: We're passionate about giving back to our community, and we support our employees in doing the same with up to 4 hours per month of employer-sponsored volunteer time.</li> <li>Mental health support: We care about the mental health of our team members and offer access to Spill, our mental health support partner.</li> <li>Workplace pension: We want you to feel secure about your future, so we offer a workplace pension with a 5% employee contribution and a 3% employer top-up.</li> <li>Learning and development: After 1 year of service, you'll have access to £500 from the Kroo Learning Fund to invest in your career development.</li> <li>Top-notch equipment: We provide top-of-the-line equipment necessary for smooth hybrid work, including a MacBook laptop. Additionally, we also offer support in establishing your home office by contributing towards your setup if required.</li> <li>Modern office: When you're in the office, you'll enjoy access to our modern, bustling workspace in Holborn, Central London, which includes a full gym.</li> <li>Cycle to Work scheme: We encourage sustainable transportation with our Cycle to Work scheme.</li> <li>Electric Car scheme: We're committed to reducing our carbon footprint, and our Electric Car scheme makes it easy for our employees to do the same.</li> <li>Enhanced parental leave: We know that family comes first, and we offer an enhanced parental leave policy to support our employees in starting and growing their families.</li> <li>Room for growth: As a fast-paced, high-growth start-up, we're dedicated to providing our employees with room to grow and excel.</li> <li>You get full healthcare for you and your nuclear family via Vitality.</li> </ul><p><br></p><p><strong>Hybrid Working:</strong></p><p>At Kroo Bank, we have a hybrid policy that gives both individuals and teams a lot of freedom when it comes to using the office space to boost productivity. Our London office is a great resource when used effectively. So, employees who can occasionally come to the office are a good fit for how we work right now. Keep in mind that this job involves working from Monday to Friday, with a mix of remote and office work, so you won't need to be on-site all the time.</p><p></p><p><strong>Diversity and Inclusion:</strong></p><p>We wholeheartedly uphold our commitment to fostering a diverse and inclusive workplace. Every employee is highly regarded, respected, and supported without any form of judgement or prejudice. We consider Diversity, Equality, and Inclusion as fundamental pillars guiding our path in all aspects of our bank. We also ensure that reasonable adjustments are made available to all candidates throughout the recruitment process.</p><p></p><p><strong>To all Recruitment Agencies:</strong></p><p>At Kroo Bank, agency resumes are strictly prohibited. Do not submit agency resumes or forward them to our job advertisements or Kroo Bank employees. Be aware that Kroo Bank will not assume any responsibility for fees incurred due to unsolicited resumes.</p><p>To ensure a fair and efficient application process, all candidates are kindly requested to submit their applications directly through the advertised platform. We kindly ask that you refrain from reaching out to the company or its employees via email, LinkedIn, or any other communication channels for inquiries or updates. Please note that any attempts to contact us through these channels will not receive a response. Thank you for your understanding and cooperation. </p><p></p>"},{"title":"Customer Support Specialist","shortcode":"73E5769864","code":"","employment_type":"Full-time","telecommuting":false,"department":"Operations","url":"https://apply.workable.com/j/73E5769864","shortlink":"https://apply.workable.com/j/73E5769864","application_url":"https://apply.workable.com/j/73E5769864/apply","published_on":"2024-07-02","created_at":"2022-05-31","country":"United Kingdom","city":"London","state":"England","education":"","experience":"Associate","function":"","industry":"Information Technology and Services","locations":[{"country":"United Kingdom","countryCode":"GB","city":"London","region":"England","hidden":false}],"description":"<p><strong>What We’re All About at Kroo<br></strong></p><p>Kroo has a big vision. To be the first bank that is both trusted and loved by its customers. We’re helping people take control of their financial future and achieve their goals, whilst making a positive impact on the planet.</p><p><br></p><p>Here at Kroo, doing what is right is in our DNA. We act with integrity, transparency and honesty. We think big, dream big, and relentlessly pursue our goals. We like to be bold, break new ground, and we never stop learning. But most importantly, we are on this journey together.</p><p><br></p> <p>As a Customer Support Specialist, you'll be the first point of contact for our customers and you’ll be helping solve any queries and help troubleshoot any problems. Put simply, our Customer Support Specialists are the digital face of Kroo!</p> <p><br></p><p>We believe our people and culture are what makes Kroo different, so we’re keen to promote people development within the company so you’ll also get the chance to broaden your skill-set and experience. We work in cross-functional collaborative teams, so you’ll also work alongside our product teams and developers to improve the customer experience on a day-to-day basis as well as the wider organisation.</p> <p>The Kroo is growing and we’d love to hear from you if you’re interested in joining us in our journey.</p><p><br></p> <p><strong>Here's what you will be doing: </strong></p><ul> <li>Provide and maintain exceptionally high levels of customer service via live chat, email, phone and social media</li> <li>Be the first port of call for customer complaints and concerns to make sure that they're treated fairly</li> <li>Show proactiveness and ownership skills to solve customer problems</li> <li>Proactively spot patterns in the frustrations or hopes of our customers, seeing where we can change our processes, tools or product to serve them better</li> <li>Identify customers who might be vulnerable and ensure we support them when needed</li> <li>Work closely with our financial crime team to act as the first line of defence to help spot and investigate trends</li> <li>Understand, prioritise and escalate customers' feedback and feature requests to the product team</li> <li>Support other members in the Operations team by being a point of contact and mentoring new joiners</li> </ul><p><strong>Requirements</strong></p><p><strong>We’re looking for someone who: </strong><br></p><ul> <li>Has front line or back office banking experience</li> <li>Has experience in customer service in the financial services industry</li> <li>Is interested in how technology can improve people's lives</li> <li>Enjoys the startup environment</li> <li>Is customer focused</li> <li>Has a high level of organisation</li> <li>Has excellent written and verbal communication skills</li> <li>Has a high level of empathy and the ability to connect with other people</li> </ul><p><strong>Benefits</strong></p><p><strong>What we offer:</strong><br></p><p>At our cutting-edge fintech company, we know that attracting and retaining the best talent means offering top-notch benefits that help our employees thrive both in and outside of work. Check out what we currently offer:</p><ul> <li>Generous holiday time: 25 days annual leave, 8 bank holidays, 1 Kroo bank holiday (June 24th), and 1 day off during the week of your birthday.</li> <li>Personal days: We know that life can be unpredictable, so we offer 3 personal days to use as needed.</li> <li>Employer-sponsored volunteer program: We're passionate about giving back to our community, and we support our employees in doing the same with up to 4 hours per month of employer-sponsored volunteer time.</li> <li>Mental health support: We care about the mental health of our team members and offer access to Spill, our mental health support partner.</li> <li>Workplace pension: We want you to feel secure about your future, so we offer a workplace pension with a 5% employee contribution and a 3% employer top-up.</li> <li>Learning and development: After 1 year of service, you'll have access to £500 from the Kroo Learning Fund to invest in your career development.</li> <li>Top-notch equipment: We provide top-of-the-line equipment necessary for smooth hybrid work, including a MacBook laptop. Additionally, we also offer support in establishing your home office by contributing towards your setup if required.</li> <li>Modern office: When you're in the office, you'll enjoy access to our modern, bustling workspace in Holborn, Central London, which includes a full gym.</li> <li>Cycle to Work scheme: We encourage sustainable transportation with our Cycle to Work scheme.</li> <li>Electric Car scheme: We're committed to reducing our carbon footprint, and our Electric Car scheme makes it easy for our employees to do the same.</li> <li>Enhanced parental leave: We know that family comes first, and we offer an enhanced parental leave policy to support our employees in starting and growing their families.</li> <li>Room for growth: As a fast-paced, high-growth start-up, we're dedicated to providing our employees with room to grow and excel.</li> <li>You get full healthcare for you and your nuclear family via Vitality.</li> </ul><p></p><p></p><p><strong>About Our Process:</strong></p><p>We can be flexible with the structure of our interview process if someone's circumstances or timescales require it but our general structure is:</p><ul> <li>People screen and quiz interview - 45 mins</li> <li>Technical interview challenge with the hiring manager - 45 mins</li> <li>Head of division interview - 45 mins</li> </ul><p>Successful candidates after the technical stage will be invited to informally meet the team in person and see our fantastic offices. Please let us know if you have any specific requirements or need assistance so we can be as accommodating as possible for you.</p><p></p><p><strong>Hybrid Working:</strong></p><p>At Kroo Bank, we embrace a hybrid policy that grants individuals and teams a considerable level of autonomy regarding office usage, maximising productivity. Our office in London is a splendid space that serves as a valuable and potent resource when utilised appropriately. Presently, we follow a blended working model, where employees are expected to work in the office for 1-2 days a week. Therefore, candidates who are able to occasionally commute to the office align best with our current work practices. Please bear in mind that this position entails working shifts over 5 days, totalling 37.5 hours per week. The shift schedule will be provided well in advance, typically spanning from 6 am to 10 pm.</p><p></p><p><strong>Diversity and Inclusion:</strong></p><p>We wholeheartedly uphold our commitment to fostering a diverse and inclusive workplace. Every employee is highly regarded, respected, and supported without any form of judgement or prejudice. We consider Diversity, Equality, and Inclusion as fundamental pillars guiding our path in all aspects of our bank. We also ensure that reasonable adjustments are made available to all candidates throughout the recruitment process.</p><p></p><p><strong>To all Recruitment Agencies:</strong></p><p>At Kroo Bank, agency resumes are strictly prohibited. Do not submit agency resumes or forward them to our job advertisements or Kroo Bank employees. Be aware that Kroo Bank will not assume any responsibility for fees incurred due to unsolicited resumes.</p><p>To ensure a fair and efficient application process, all candidates are kindly requested to submit their applications directly through the advertised platform. We kindly ask that you refrain from reaching out to the company or its employees via email, LinkedIn, or any other communication channels for inquiries or updates. Please note that any attempts to contact us through these channels will not receive a response. Thank you for your understanding and cooperation.<br></p>"},{"title":"Detection Team Senior FinCrime Analyst","shortcode":"D7625E3CAD","code":"","employment_type":"Full-time","telecommuting":true,"department":"Fin Crime/ Fraud Operations","url":"https://apply.workable.com/j/D7625E3CAD","shortlink":"https://apply.workable.com/j/D7625E3CAD","application_url":"https://apply.workable.com/j/D7625E3CAD/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United Kingdom","city":"Manchester","state":"England","education":"","experience":"Mid-Senior level","function":"","industry":"Banking","locations":[{"country":"United Kingdom","countryCode":"GB","city":"Manchester","region":"England","hidden":false}],"description":"<p><strong>What We’re All About at Kroo</strong></p><p>Kroo has a big vision. To be the first Bank that is both trusted and loved by its customers. We’re helping people take control of their financial future and achieve their goals, whilst making a positive impact on the planet. Here at Kroo, doing what is right is in our DNA. We act with integrity, transparency and honesty. We think big, dream big, and relentlessly pursue our goals. We like to be bold, break new ground, and we never stop learning. But most importantly, we are on this journey together.</p><p><strong>About the Team</strong></p><p>We are a multi-disciplined team of experienced technology, banking, customer experience, marketing, and legal professionals who share a passion for the company’s mission and believe in a collaborative approach to creating the greatest social bank. We are building a diverse team of inquisitive people who want to understand customer needs and behaviour so we can develop innovative products that change people’s lives for good.</p><p><strong>What you’ll do:&nbsp;</strong></p><ul> <li>Support the day-to-day operations of Kroo’s 1st Line Financial Crime Detection Team.</li> <li>Act as a point of escalation and support the wider team with best-practice guidance on how to manage reviews.</li> <li>Investigate transaction monitoring alerts to identify suspicious activity.</li> <li>Support and deputise the Detection Team Lead to ensure the team meet objectives.</li> <li>Conduct thorough reviews of periodic or enhanced due diligence alerts.</li> <li>Proactively identify financial crime trends through data analysis.</li> <li>Swiftly and effectively execute payment reviews delivering a positive customer experience whilst protecting customers and the bank from risk.</li> <li>Liaise with other financial institutions and law enforcement authorities.</li> <li>Liaise with other business departments.</li> <li>Support the optimisation and update of existing processes, systems and procedures.</li> </ul><p><strong>Requirements</strong></p><ul><li>2 years experience (minimum) in a fraud or financial crime role.</li></ul><ul> <li>Experience managing escalations and supporting investigations.</li> <li>The ability and knowledge to coach and develop junior members of the team.</li> <li>An inquisitive and proactive attitude.</li> <li>The ability to manage a varied workload and meet SLAs.</li> </ul><ul><li>An analytical mindset and capable of identifying patterns in large datasets.</li></ul><ul> <li>A cooperative character and you enjoy working as part of a dynamic team.</li> <li>Excellent communication skills.</li> </ul><p><strong>Benefits</strong></p><p></p><ul> <li>Competitive salary and share options&nbsp;</li> <li>33 days holiday (including public holidays). In addition, you’ll also get your birthday on us.</li> <li>Personal Health days.</li> <li>Access to our company pension scheme (currently 3% employer contribution).</li> <li>All the equipment you need to work effectively.</li> <li>A high degree of autonomy with support from an experienced and supportive team</li> <li>Room to grow and excel within a fast-paced, high grow growing start-up</li> <li>An ethically conscious company that is truly trying to change what's most broken about the industry</li> <li>Access to a learning budget to continue your professional development.</li> </ul><p></p><p><strong>Office/remote working and working times:</strong></p><p>The role will be remote-first, meaning that the majority of work will be completed from home, with occasional on site working required in Manchester city centre. Please note onboarding and training for the role will be conducted remotely.<br><br>Our ambition is to be a truly 24/7 customer-focused bank. In order to achieve this, you'll be working 5 shifts (Monday - Sunday) and 37.5 hours per week. The shifts will be provided well in advance, but typically range between 07:00 - 19:30.</p><p></p><p><strong>Diversity</strong>:</p><p>We are firmly committed to creating and maintaining a diverse and inclusive workplace in which all employees are valued, respected, safe, supported, and listened to without judgement or prejudice. These principles apply to all, regardless of race or ethnicity, age, gender, gender identity or expression, national origin, sexual orientation, mental or physical ability, religion, appearance, political beliefs, educational background, class, and position or tenure within the company. Diversity, Equity, and Inclusion are central to the direction we take at Kroo, and are considered across all aspects of our business.</p>"},{"title":"Head of FinCrime & MLRO in FinCrime (2nd Line, SMF17)","shortcode":"6D8E359354","code":"HOFMLRO","employment_type":"Full-time","telecommuting":false,"department":"Risk & Compliance","url":"https://apply.workable.com/j/6D8E359354","shortlink":"https://apply.workable.com/j/6D8E359354","application_url":"https://apply.workable.com/j/6D8E359354/apply","published_on":"2024-06-13","created_at":"2024-06-07","country":"United Kingdom","city":"London","state":"England","education":"","experience":"Mid-Senior level","function":"","industry":"Financial Services","locations":[{"country":"United Kingdom","countryCode":"GB","city":"London","region":"England","hidden":false}],"description":"<p><strong>What We’re All About at Kroo</strong></p><p>Kroo has a big vision. To be the first Bank that is both trusted and loved by its customers. We’re helping people take control of their financial future and achieve their goals, whilst making a positive impact on the planet. Here at Kroo, doing what is right is in our DNA. We act with integrity, transparency and honesty. We think big, dream big, and relentlessly pursue our goals. We like to be bold, break new ground, and we never stop learning. But most importantly, we are on this journey together.</p><p></p><p><strong>How you will contribute:</strong></p><p>As the Head of FinCrime &amp; MLRO, you are expected to lead our Financial Crime function in the 2nd Line of Defence with expertise and enthusiasm. The role is an SMF17 and will require regulatory approval. Your role is pivotal in ensuring Kroo Bank remains compliant with UK regulations and effectively manages financial crime risks. We expect you to bring a deep understanding of financial crime compliance, robust leadership skills, and the ability to foster a culture of compliance and ethical behaviour across the organisation. Other responsibilities include: \t\t\t\t\t\t</p><p> </p><p>● Strategic Oversight and Leadership</p><p>○ Develop and Implement FinCrime Expertise: Support the business and help execute on strategies to reduce risk related to money laundering, fraud, terrorist financing, bribery, and corruption, ensuring they align with the bank's overall objectives.</p><p>○ Policy and Framework Development: Design, implement, and maintain robust financial crime policies and frameworks to ensure compliance with UK regulatory requirements (e.g., FCA and PRA guidelines).</p><p>○ Risk Assessment and Management: Conduct regular assessments of financial crime risks, develop plans to mitigate these risks, and oversee the implementation of risk management processes and controls.</p><p>○ Leadership and Team Management: Lead and manage the FinCrime (2LOD) team, including recruiting, training, and professional development, and promote a culture of compliance and ethical behaviour across the organisation.</p><p>○ Regulatory Compliance and Reporting.</p><p>○ MLRO Responsibilities: Serve as the Money Laundering Reporting Officer (MLRO) for the bank, ensuring all</p><p>regulatory obligations are met and reporting suspicious activities to the National Crime Agency (NCA) and other</p><p>relevant authorities.</p><p>○ Regulatory Engagement: Act as the main point of contact with regulatory bodies on financial crime matters, ensuring</p><p>timely and accurate submission of regulatory reports and responses to inquiries.</p><p>○ Compliance Monitoring and Testing: Develop and execute compliance monitoring and testing programs, conducting</p><p>regular reviews and audits to ensure adherence to internal policies and regulatory requirements.</p><p></p><p>● Operational Excellence</p><p>○ Transaction Monitoring and Analysis: Oversee systems that monitor transactions to detect and prevent financial crime, analysing transaction patterns to identify potential risks.</p><p>○ Incident Management and Investigation: Support the business with investigations into suspected financial crime incidents, coordinating with internal and external stakeholders to resolve incidents and implement corrective actions.</p><p>○ Data and Technology Utilisation: Use advanced data analytics and technology to enhance financial crime detection and prevention, ensuring the effectiveness and efficiency of detection systems.</p><p></p><p>● Stakeholder Collaboration and Communication</p><p>○ Internal Collaboration: Work closely with other departments (e.g FinCrime Operations, COO, Risk, Compliance, Legal, Operations) to ensure a cohesive approach to financial crime risk management, and provide expert advice and guidance to senior management and the board.</p><p>○ Training and Awareness: Develop and deliver training programs on financial crime for employees, promoting awareness and understanding of financial crime risks and controls throughout the organisation.</p><p></p><p>● Continuous Improvement and Industry Engagement</p><p>○ Continuous Improvement: Stay updated on emerging financial crime trends, regulatory changes, and best practices, and continuously improve the bank's financial crime framework to address new threats and regulatory requirements.</p><p>○ Industry Engagement: Represent the bank in industry forums, working groups, and regulatory consultations, and build and maintain relationships with industry peers, regulators, and law enforcement agencies.</p><p></p><p>● Reporting and Metrics</p><p>○ Governance Reporting to Senior Management and the Board: Provide regular updates and reports on financial crime risk management activities, including key metrics and risk indicators, and present findings from investigations and risk assessments to senior management and the board.</p><p></p><p>The Kroo is growing and we’d love to hear from you if you’re interested in joining us on our journey!</p><p></p><h3></h3><p><strong>Requirements</strong></p><p><strong>About You</strong></p><p>While not essential, the following experience and qualifications are highly desirable in our ideal candidate for this position:</p><ul> <li>Proven experience in a senior financial crime compliance role within a financial institution, preferably in a bank or fintech environment, and with experience as an SMF17.</li> <li>Extensive experience in retail banking, specifically overseeing financial crime compliance.</li> <li>Comprehensive knowledge of UK and International regulatory requirements related to financial crime, including FCA, PRA, and PSR guidelines.</li> <li>Strong leadership skills with a track record of managing and developing high-performing teams.</li> <li>Excellent analytical and problem-solving abilities, with experience in using data analytics and technology for financial crime detection.</li> <li>Strong understanding of FinCrime industry best practices and the ability to support the business with implementation.</li> <li>Effective communication and stakeholder management skills, with the ability to influence and engage at all levels of the organisation.</li> <li>Professional qualifications such as ICA Diploma in Anti Money Laundering or equivalent are highly desirable.</li> </ul><p></p><p><strong>About Our Process:</strong></p><p>We can be flexible with the structure of our interview process if someone's circumstances or timescales require it but our general structure is:<br></p><ul> <li>30-minute meet and greet with our talent acquisition specialist via google hangouts.</li> <li>1-hour technical interview. R&amp;C /CRO interview via google hangouts.</li> <li>30-minute ManCo/1st Line interview via google hangouts.</li> <li>30-minute Tech interview via google hangouts.</li> <li>45-minute Final interview&nbsp;via google hangouts.<br> </li> </ul><p>Please let us know if you have any specific requirements or need assistance so we can be as accommodating as possible for you.</p><p></p><p><strong>Benefits</strong></p><p><strong>What we offer:</strong></p><p>At our cutting-edge fintech company, we know that attracting and retaining the best talent means offering top-notch benefits that help our employees thrive both in and outside of work. Check out what we currently offer:</p><p></p><ul> <li>Generous holiday time: 25 days annual leave, 8 bank holidays, 1 Kroo bank holiday (June 24th), and 1 day off during the week of your birthday.</li> <li>Personal days: We know that life can be unpredictable, so we offer 3 personal days to use as needed.</li> <li>Employer-sponsored volunteer program: We're passionate about giving back to our community, and we support our employees in doing the same with up to 4 hours per month of employer-sponsored volunteer time.</li> <li>Mental health support: We care about the mental health of our team members and offer access to Spill, our mental health support partner.</li> <li>Workplace pension: We want you to feel secure about your future, so we offer a workplace pension with a 5% employee contribution and a 3% employer top-up.</li> <li>Learning and development: After 1 year of service, you'll have access to £500 from the Kroo Learning Fund to invest in your career development.</li> <li>Top-notch equipment: We provide top-of-the-line equipment necessary for smooth hybrid work, including a MacBook laptop. Additionally, we also offer support in establishing your home office by contributing towards your setup if required.</li> <li>Modern office: When you're in the office, you'll enjoy access to our modern, bustling workspace in Holborn, Central London, which includes a full gym.</li> <li>Cycle to Work scheme: We encourage sustainable transportation with our Cycle to Work scheme.</li> <li>Electric Car scheme: We're committed to reducing our carbon footprint, and our Electric Car scheme makes it easy for our employees to do the same.</li> <li>Enhanced parental leave: We know that family comes first, and we offer an enhanced parental leave policy to support our employees in starting and growing their families.</li> <li>Room for growth: As a fast-paced, high-growth start-up, we're dedicated to providing our employees with room to grow and excel.</li> <li>You get full healthcare for you and your nuclear family via Vitality.</li> </ul><p><br></p><p><strong>Hybrid Working:</strong></p><p>At Kroo Bank, we have a hybrid policy that gives both individuals and teams a lot of freedom when it comes to using the office space to boost productivity. Our London office is a great resource when used effectively. So, employees who can occasionally come to the office are a good fit for how we work right now. Keep in mind that this job involves working from Monday to Friday, with a mix of remote and office work, so you won't need to be on-site all the time.</p><p></p><p><strong>Diversity and Inclusion:</strong></p><p>We wholeheartedly uphold our commitment to fostering a diverse and inclusive workplace. Every employee is highly regarded, respected, and supported without any form of judgement or prejudice. We consider Diversity, Equality, and Inclusion as fundamental pillars guiding our path in all aspects of our bank. We also ensure that reasonable adjustments are made available to all candidates throughout the recruitment process.</p><p></p><p><strong>To all Recruitment Agencies:</strong></p><p>At Kroo Bank, agency resumes are strictly prohibited. Do not submit agency resumes or forward them to our job advertisements or Kroo Bank employees. Be aware that Kroo Bank will not assume any responsibility for fees incurred due to unsolicited resumes.</p><p>To ensure a fair and efficient application process, all candidates are kindly requested to submit their applications directly through the advertised platform. We kindly ask that you refrain from reaching out to the company or its employees via email, LinkedIn, or any other communication channels for inquiries or updates. Please note that any attempts to contact us through these channels will not receive a response. Thank you for your understanding and cooperation. </p><p></p>"},{"title":"Senior Security Engineer","shortcode":"C4002EDABE","code":"","employment_type":"Full-time","telecommuting":true,"department":"Technology","url":"https://apply.workable.com/j/C4002EDABE","shortlink":"https://apply.workable.com/j/C4002EDABE","application_url":"https://apply.workable.com/j/C4002EDABE/apply","published_on":"2024-06-13","created_at":"2023-02-07","country":"United Kingdom","city":"London","state":"England","education":"","experience":"Mid-Senior level","function":"Engineering","industry":"Information Technology and Services","locations":[{"country":"United Kingdom","countryCode":"GB","city":"London","region":"England","hidden":false}],"description":"<p>At Kroo Bank, we are charting the future of banking with our groundbreaking technological innovations and unique digital services. The rapid advancements in the fintech sector necessitate ongoing evolution in the roles and responsibilities of our bank to effectively tackle new business opportunities and challenges. We are dedicated to consistently updating our job descriptions to ensure we continue to lead in banking innovation.</p><p></p><p><strong>How you will contribute and key responsibilities:&nbsp;</strong></p><p>As a Senior Security Engineer, you will be instrumental in designing and implementing security measures for our mobile applications, services, and websites to meet the highest security standards. Your expertise will help us continuously analyse and improve our security systems, ensuring that our products and services are not only secure by design but also comply with internal and external regulatory requirements. Other responsibilities include:&nbsp;</p><p></p><ul> <li>Security Analysis and Improvement: Continuously analyse our security systems for potential improvements, ensuring that our defences remain at the forefront of cybersecurity practices.</li> <li>Vulnerability Management: Proactively identify, assess, and remediate security vulnerabilities to maintain the integrity and confidentiality of our customer data.</li> <li>Security Automation: Automate security processes and procedures to enhance efficiency and effectiveness, reducing the risk of human error.</li> <li>Security Requirements and Solutions: Identify, define, and document system security requirements, providing well-considered recommendations to management.</li> <li>Development of Security Standards: Develop and maintain best practices and security standards for the organisation, guiding teams in the implementation of secure coding practices.</li> <li>Secure Design: Collaborate with development teams to ensure that web and mobile front-ends, as well as microservice architectures, are designed with robust security measures in mind.</li> <li>Risk Management and Compliance: Assist teams in ensuring that products and services are secure by design, align with the organisation's risk appetite, and comply with all relevant group standards, policies, and regulatory requirements.</li> <li>Cybersecurity Collaboration: Work closely with stakeholders across the organisation to align security measures with our overarching cybersecurity strategy and protect the bank’s technology infrastructure.</li> <li>Regulatory Compliance: Support teams in meeting compliance requirements for internal audits and external regulators, safeguarding against potential fines and reputational damage.</li> </ul><p></p><p></p><p><strong>Requirements</strong></p><p>To be successful in this role you should have skills and experience in multiple domains, such as application security, network security or security operations. You need to have programming experience and the ability to proactively seek out efficient and repetitive solutions to security challenges. At a minimum, you should have at least 3 years of experience in system, network or application security. You should also have a proven experience and knowledge with any combination of the following:</p><ul> <li>Threat modelling and risk assessments,</li> <li>Working knowledge of secure coding principles (OWASP and OWASP mobile, SANS…),</li> <li>Experience with designing and administering identity management (authentication and authorisation including policy enforcement points, token services, protocols such as OAuth2),</li> <li>Working knowledge of cryptography including encryption, signing and digital certificates,</li> <li>Principles of securing mobile applications and web services,</li> <li>Docker or kubernetes and infrastructure as code,</li> <li>Event driven streaming technologies,</li> <li>Logging and monitoring, networks, firewalls, load balancers, DNS, CDNs,</li> <li>Working knowledge of agile DevSecOps environments, and CI/CD (Git, Concourse, Terraform),</li> <li>Working knowledge of SAST, DAST, RASP, and IAST tools and building security into existing SDLC processes,</li> <li>Knowledge of cloud Security Architecture of public clouds (such as AWS or GCP),</li> <li>Security certification such as CISSP, CCP, SANS, GAIC, Ethical Hacker,</li> <li>Experience in working in regulated company, preferably with a FinTech/ banking background and experience in DevOps,</li> <li>Excellent oral, written communication and presentation skills.</li> </ul><p><strong>Benefits</strong></p><p><strong>What we offer:</strong></p><p>At our cutting-edge fintech company, we know that attracting and retaining the best talent means offering top-notch benefits that help our employees thrive both in and outside of work. Check out what we currently offer:</p><ul> <li>Generous holiday time: 25 days annual leave, 8 bank holidays, 1 Kroo bank holiday (June 24th), and 1 day off during the week of your birthday.</li> <li>Personal days: We know that life can be unpredictable, so we offer 3 personal days to use as needed.</li> <li>Employer-sponsored volunteer program: We're passionate about giving back to our community, and we support our employees in doing the same with up to 4 hours per month of employer-sponsored volunteer time.</li> <li>Mental health support: We care about the mental health of our team members and offer access to Spill, our mental health support partner.</li> <li>Workplace pension: We want you to feel secure about your future, so we offer a workplace pension with a 5% employee contribution and a 3% employer top-up.</li> <li>Learning and development: After 1 year of service, you'll have access to £500 from the Kroo Learning Fund to invest in your career development.</li> <li>Top-notch equipment: We provide top-of-the-line equipment necessary for smooth hybrid work, including a MacBook laptop. Additionally, we also offer support in establishing your home office by contributing towards your setup if required.</li> <li>Modern office: When you're in the office, you'll enjoy access to our modern, bustling workspace in Holborn, Central London, which includes a full gym.</li> <li>Cycle to Work scheme: We encourage sustainable transportation with our Cycle to Work scheme.</li> <li>Electric Car scheme: We're committed to reducing our carbon footprint, and our Electric Car scheme makes it easy for our employees to do the same.</li> <li>Enhanced parental leave: We know that family comes first, and we offer an enhanced parental leave policy to support our employees in starting and growing their families.</li> <li>Room for growth: As a fast-paced, high-growth start-up, we're dedicated to providing our employees with room to grow and excel.</li> <li>You get full healthcare for you and your nuclear family via Vitality.</li> </ul><p></p><p><strong>Hybrid Working:</strong></p><p>At Kroo Bank, we have a hybrid policy that gives both individuals and teams a lot of freedom when it comes to using the office space to boost productivity. Our London office is a great resource when used effectively. So, employees who can occasionally come to the office are a good fit for how we work right now. Keep in mind that this job involves working from Monday to Friday, with a mix of remote and office work, so you won't need to be on-site all the time.</p><p></p><p><strong>Diversity and Inclusion:</strong></p><p>We wholeheartedly uphold our commitment to fostering a diverse and inclusive workplace. Every employee is highly regarded, respected, and supported without any form of judgement or prejudice. We consider Diversity, Equality, and Inclusion as fundamental pillars guiding our path in all aspects of our bank. We also ensure that reasonable adjustments are made available to all candidates throughout the recruitment process.</p><p></p><p><strong>To all Recruitment Agencies:</strong></p><p>At Kroo Bank, agency resumes are strictly prohibited. Do not submit agency resumes or forward them to our job advertisements or Kroo Bank employees. Be aware that Kroo Bank will not assume any responsibility for fees incurred due to unsolicited resumes.</p><p>To ensure a fair and efficient application process, all candidates are kindly requested to submit their applications directly through the advertised platform. We kindly ask that you refrain from reaching out to the company or its employees via email, LinkedIn, or any other communication channels for inquiries or updates. Please note that any attempts to contact us through these channels will not receive a response. Thank you for your understanding and cooperation.</p>"},{"title":"Technical Operations Associate","shortcode":"8626350C83","code":"","employment_type":"Full-time","telecommuting":true,"department":"Technology","url":"https://apply.workable.com/j/8626350C83","shortlink":"https://apply.workable.com/j/8626350C83","application_url":"https://apply.workable.com/j/8626350C83/apply","published_on":"2024-07-11","created_at":"2024-07-11","country":"United Kingdom","city":"London","state":"England","education":"","experience":"Mid-Senior level","function":"","industry":"","locations":[{"country":"United Kingdom","countryCode":"GB","city":"London","region":"England","hidden":false}],"description":"<p>At Kroo Bank, we are charting the future of banking with our groundbreaking technological innovations and unique digital services. The rapid advancements in the fintech sector necessitate ongoing evolution in the roles and responsibilities of our bank to effectively tackle new business opportunities and challenges. We are dedicated to consistently updating our job descriptions to ensure we continue to lead in banking innovation.</p><p></p><p><strong>How you will contribute and key responsibilities:&nbsp;</strong></p><p>As a Technical Operations Associate, you'll play a critical role in assisting with the Operational Resilience, efficiency, and reliability of our platform. Working within the Technical Operations Team, you'll utilise your technical expertise to support risk management, automate processes, and enhance system performance. Collaborating closely with teams across the business, you'll help foster a culture of continuous improvement and operational excellence. Other responsibilities include:</p><ul> <li>Assist in logging and tracking vulnerabilities and risks, coordinating with internal stakeholders to ensure comprehensive risk management in line with FCA &amp; PRA regulations.</li> <li>Support the development and maintenance of a comprehensive library of scenario tests, including Business Continuity Planning (BCP) and Disaster Recovery (DR) exercises for business services.</li> <li>Monitor and report compliance with Key Risk Indicators and impact tolerances, assisting in the implementation of Incident Management/Service Level Objectives (IM/SLO) reporting to track performance of services..</li> <li>Assist in conducting regular self-assessments to evaluate compliance with regulatory standards, document findings, and assist in implementing action plans to address gaps or deficiencies.</li> <li>Assist in maintaining and testing Business Continuity Plans (BCPs) to ensure readiness for any disruptions.</li> <li>Support robust processes for managing incidents and changes.</li> <li>Utilise Make.com to assist in creating automation scenarios that enhance operational efficiency.</li> <li>Participate in the on-call schedule for Major Incident Management.</li> <li>Stay abreast of industry trends and best practices in operational resilience, introducing innovative tools and technologies to drive improvements.</li> <li>Document system design and operational procedures, sharing knowledge across teams to foster a collaborative working environment.</li> </ul><p><br><br></p><p></p><p></p><p><strong>Requirements</strong></p><p>While not essential, the following experience is highly desirable in our ideal candidate for this position:</p><ul> <li> <strong>Versatility and Quick Learning:</strong> Ability to quickly grasp new concepts and technologies, adapt to changing environments and requirements, and effectively implement new ideas.</li> <li> <strong>Data Analysis and Insight Generation:</strong> Proficiency in analysing data patterns to identify potential faults and enhancements. Capable of providing actionable insights and recommendations for system improvements and training team members in data analysis techniques.</li> <li> <strong>Solution-Oriented Problem Solving:</strong> Skill in identifying root causes of incidents and implementing effective solutions to improve service reliability. Ability to actively contribute to team discussions on reliability and guide junior team members.</li> <li> <strong>Project Management and Execution:</strong> Competence in managing tasks and projects efficiently within established timelines. Ability to adjust plans as necessary to meet changing requirements and contribute to team projects with growing independence.</li> <li> <strong>Effective Decision-Making:</strong> Strong decision-making skills, considering both immediate and long-term implications. Ability to engage stakeholders appropriately and make independent decisions in most situations.</li> <li> <strong>Process Adherence and Improvement:</strong> Adherence to incident and change management processes effectively. Capability to manage medium to high complexity incidents and changes confidently, and contribute to the improvement of existing processes.</li> <li> <strong>Service Architecture Understanding:</strong> Comprehensive understanding of service architecture. Ability to provide valuable insights for architectural decisions and discuss architectural elements independently.</li> <li> <strong>Supplier Relationship Management:</strong> Skill in building and maintaining positive relationships with suppliers, addressing challenges independently, and contributing to stronger supplier connections.</li> <li> <strong>Risk and Business Continuity Management:</strong> Ability to support logging and tracking of vulnerabilities and risks, ensuring comprehensive risk management in line with FCA &amp; PRA regulations. Assist in maintaining and testing Business Continuity Plans (BCPs) to ensure readiness for disruptions.</li> <li> <strong>Automation and Operational Efficiency:</strong> Proficiency in utilising Make.com and other automation tools to create scenarios that enhance operational efficiency. Continuously seeking opportunities to automate processes and improve productivity.</li> <li> <strong>Industry Knowledge and Innovation:</strong> Awareness of industry trends and best practices in operational resilience. Capability to introduce innovative tools and technologies to drive continuous improvements and operational excellence.</li> </ul><p></p><p></p><p><strong>About Our Process:</strong></p><p>We can be flexible with the structure of our interview process if someone's circumstances or timescales require it but our general structure is:<br></p><ul> <li>30-minute people screen with our talent acquisition specialist via google hangouts.</li> <li>1-hour technical interview interview via google hangouts.</li> <li>45-minute final interview&nbsp;via google hangouts.<br> </li> </ul><p>Please let us know if you have any specific requirements or need assistance so we can be as accommodating as possible for you.</p><p></p><p><strong>Benefits</strong></p><p><strong>What we offer:</strong></p><p>At our cutting-edge fintech company, we know that attracting and retaining the best talent means offering top-notch benefits that help our employees thrive both in and outside of work. Check out what we currently offer:</p><ul> <li>Generous holiday time: 25 days annual leave, 8 bank holidays, 1 Kroo bank holiday (June 24th), and 1 day off during the week of your birthday.</li> <li>Personal days: We know that life can be unpredictable, so we offer 3 personal days to use as needed.</li> <li>Employer-sponsored volunteer program: We're passionate about giving back to our community, and we support our employees in doing the same with up to 4 hours per month of employer-sponsored volunteer time.</li> <li>Mental health support: We care about the mental health of our team members and offer access to Spill, our mental health support partner.</li> <li>Workplace pension: We want you to feel secure about your future, so we offer a workplace pension with a 5% employee contribution and a 3% employer top-up.</li> <li>Learning and development: After 1 year of service, you'll have access to £500 from the Kroo Learning Fund to invest in your career development.</li> <li>Top-notch equipment: We provide top-of-the-line equipment necessary for smooth hybrid work, including a MacBook laptop. Additionally, we also offer support in establishing your home office by contributing towards your setup if required.</li> <li>Modern office: When you're in the office, you'll enjoy access to our modern, bustling workspace in Holborn, Central London, which includes a full gym.</li> <li>Cycle to Work scheme: We encourage sustainable transportation with our Cycle to Work scheme.</li> <li>Electric Car scheme: We're committed to reducing our carbon footprint, and our Electric Car scheme makes it easy for our employees to do the same.</li> <li>Enhanced parental leave: We know that family comes first, and we offer an enhanced parental leave policy to support our employees in starting and growing their families.</li> <li>Room for growth: As a fast-paced, high-growth start-up, we're dedicated to providing our employees with room to grow and excel.</li> <li>You get full healthcare for you and your nuclear family via Vitality.</li> </ul><p></p><p><strong>Hybrid Working:</strong></p><p>At Kroo Bank, we have a hybrid policy that gives both individuals and teams a lot of freedom when it comes to using the office space to boost productivity. Our London office is a great resource when used effectively. So, employees who can occasionally come to the office are a good fit for how we work right now. Keep in mind that this job involves working from Monday to Friday, with a mix of remote and office work, so you won't need to be on-site all the time.</p><p></p><p><strong>Diversity and Inclusion:</strong></p><p>We wholeheartedly uphold our commitment to fostering a diverse and inclusive workplace. Every employee is highly regarded, respected, and supported without any form of judgement or prejudice. We consider Diversity, Equality, and Inclusion as fundamental pillars guiding our path in all aspects of our bank. We also ensure that reasonable adjustments are made available to all candidates throughout the recruitment process.</p><p></p><p><strong>To all Recruitment Agencies:</strong></p><p>At Kroo Bank, agency resumes are strictly prohibited. Do not submit agency resumes or forward them to our job advertisements or Kroo Bank employees. Be aware that Kroo Bank will not assume any responsibility for fees incurred due to unsolicited resumes.</p><p>To ensure a fair and efficient application process, all candidates are kindly requested to submit their applications directly through the advertised platform. We kindly ask that you refrain from reaching out to the company or its employees via email, LinkedIn, or any other communication channels for inquiries or updates. Please note that any attempts to contact us through these channels will not receive a response. Thank you for your understanding and cooperation.</p>"}]}
-  recorded_at: Mon, 29 Jul 2024 09:13:54 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:24 GMT
 - request:
     method: post
     uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
@@ -211,9 +211,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:13:55 GMT
+      - Tue, 30 Jul 2024 16:26:25 GMT
       Etag:
-      - W/"1722244435408"
+      - W/"1722356785481"
       Server:
       - openresty
       X-Cb-Engine:
@@ -225,11 +225,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '4'
+      - '5'
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '14'
+      - '12'
       Content-Length:
       - '498'
       Connection:
@@ -238,6 +238,6 @@ http_interactions:
       encoding: UTF-8
       string: '{"count":1,"entities":[{"uuid":"f9cc2189-59fa-4e75-bf54-218d727db7b9","properties":{"name":"Kroo","identifier":{"permalink":"b-social","image_id":"gze3oofpsz0ou1qzdjuc","uuid":"f9cc2189-59fa-4e75-bf54-218d727db7b9","entity_def_id":"organization","value":"Kroo"},"linkedin":{"value":"https://www.linkedin.com/company/b-social-ltd/"},"short_description":"Online
         banking at your fingertips. Apply today for a feature-packed online current
-        account.","rank_org":6084,"website_url":"https://kroo.com"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:13:55 GMT
+        account.","rank_org":6052,"website_url":"https://kroo.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:26:25 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_company_workday.yml b/spec/fixtures/cassettes/create_company_workday.yml
index d2335d91..5b967a84 100644
--- a/spec/fixtures/cassettes/create_company_workday.yml
+++ b/spec/fixtures/cassettes/create_company_workday.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:56 GMT
+      - Tue, 30 Jul 2024 16:26:26 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -29,41 +29,41 @@ http_interactions:
       Vary:
       - accept-language,accept-encoding
       Set-Cookie:
-      - PLAY_SESSION=fe92e7f5c6c046ab9e09dbd8b3715833a33fdd9b-instance=vps-prod-b3a9pmrr.prod-vps.pr502.cust.pdx.wd;
+      - PLAY_SESSION=7fa302ca541deb64892492c87e28d4f504c8a775-instance=vps-prod-z33240mo.prod-vps.pr501.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=aVIWmlDttyb3vEvObhMGp2VlCVx0.EZR_HLN5ngQArg-1722244436-1.0.1.1-IkmxyDcO16sEasanQhTAMOuk5xn9ZLALt.ZlXMDuUBBeFHiFFjP0zipIaWQJYXl6o5PiNBi5EZSg.ZGKULrarA;
-        path=/; expires=Mon, 29-Jul-24 09:43:56 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=mIKedrgtBiHknPsCbKO60jEUu.jU5S3hQiOzAbgBq2w-1722356786-1.0.1.1-k3xcBM7gYiz1hhYr19jFMQCJs.7cbTT.zFcP8c3HQWWbLkn.XWn82qfmJp_SyGdIBAWB53sJZ7mPstPga7uiUA;
+        path=/; expires=Tue, 30-Jul-24 16:56:26 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLeTYyWYf7NxYcM1ms36nPHbTvwe; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:13:56 GMT; HttpOnly
-      - _cfuvid=kmi.QYUiyoiG.1DKF0w7DrMUDyTTf7OqtiCg2QwVIUo-1722244436039-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLeTYyWYf7NxYcM1LiB3HMnxBqYY; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:26 GMT; HttpOnly
+      - _cfuvid=IO2EeR9mI1XsnfHyvEyQ8NNHywEfODC5hOgO2n.Xxpg-1722356786089-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=f74a5485-17f2-4642-a0d3-19e45cd5b76e; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=3589053450.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=74aad9db-c717-4d96-9f52-8ff1f86ed0e1; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=787127306.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - max-age=259200, public,
       X-Wd-Request-Id:
-      - VPS|739b764d-fc95-40dd-b477-78ec861c8827
+      - VPS|aa689b98-6293-4e74-a134-709acbdd708b
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - BYPASS
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=VOvJKaZDHyPVG6Ww1rnFwwDUxorIBHKhn%2BxLmy3IIgoOLF6cRARHgtLfAi6s0quqeQRy79mvutyRn%2BZ7eJnOQM3Xkr8fRbYcz7eyFBugd0EJHQnTr4nJtEGxkddE8PDbRg8OVfbZLgzlLu6MwRRrwAXPu56bFljdiQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=DgPHu5BViHORNOKEh%2BMOJiRAqzEDt35c20ro1LFWHYeFlecfuVYqQ%2FPTaJjnv71qKbgrP8Le%2F7Lih%2FPTOwrRkurXqTEqjcyc%2BI9NI%2FPtIz8sZuDokErEPObI%2F9hhlcBzoKSvqccB1Ha6dOTz%2FzQV2czs%2F3OwWBhfMQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfeec2fac72b7-EWR
+      - 8ab6b5d828cb0f7c-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         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
-  recorded_at: Mon, 29 Jul 2024 09:13:56 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:26 GMT
 - request:
     method: get
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/approot
@@ -83,7 +83,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:56 GMT
+      - Tue, 30 Jul 2024 16:26:26 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -93,41 +93,42 @@ http_interactions:
       Vary:
       - accept-language,accept-encoding
       Set-Cookie:
-      - PLAY_SESSION=80b4eadbb9f00e5f0280e3b0f991a5aa9b81c887-instance=vps-prod-ybfas18y.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=d79f49ca0d10f6514f34368ab8932d1aaddcd637-instance=vps-prod-0iqhoeuq.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=eszCre.sQzDXvFBW1dQVeApA15scVw8JTOGXGmR_lac-1722244436-1.0.1.1-MaN2vMJmjnFO.Y7lM3tdEWyxilitbR1geHdqx3CqEBdenZpFPEdwvP0NAGXVaVevOK63v2T0COJE7YiUZa0BxQ;
-        path=/; expires=Mon, 29-Jul-24 09:43:56 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=Fcqs0XpOTiX8oher.9ru4KiVIqq1yEaCKrxn6PBCRy8-1722356786-1.0.1.1-jHlFnfGlvCC6urmYjaRmxC3W..qLy_Tb9uTQ8F5IGyvFAig3xoI7iNyyk5S5yuF1eLFY1LnM2vEdIYso3AYk4w;
+        path=/; expires=Tue, 30-Jul-24 16:56:26 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxfDmaMQrGN1pJY; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:13:56 GMT; HttpOnly
-      - _cfuvid=NiyutXyJrvxEudCHZgu1nY2_iQJFZApFo3KAyMLSX84-1722244436926-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxenciHupmijiuS; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:26 GMT; HttpOnly
+      - _cfuvid=knNfvq1EBYDq2vlKOdM0ExhmfTnhyyZvPYCuV.XjWSA-1722356786651-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=08613669-1e9e-424b-ad13-8ab018840255; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=1173003274.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=e1e2c888-dfb0-4327-9023-672d00af72f2; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=2313985034.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - max-age=1800, public,
       X-Wd-Request-Id:
-      - VPS|ef436594-71d7-451e-8811-19ebe8febe2c
+      - VPS|b4fad08b-b846-49b8-b85a-fbaa23e99f2e
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - BYPASS
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=7H1m7SXid%2Fsz5CGp9woGpU4MrxoIDq%2FG0jKN93eFcLMvRthtjfUjm0dfIlWi3v%2F1V%2BlaBHUaGxKGPMsNEZFsrm86jvhn7253w5stGSiUOKuMnFBFpks8WhYuSiXI0S%2FnIQKRL82cNIEAI36XFsYJCYZ70O145waX2A%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=6DRjpndQ8kiKr8X2cJ7JZYrvCoHnc8vByQpaQRXLKklDtkrPjqUxx34hOnIl4uhT4q4b6wgSoIXN8RwvrxdeBDRMerJinbORIuqg0ub9YWyr2CNjhHB9R6o%2FjeZZtdKdGxaDZePLa7e3egeDcqcLnY%2B4CFHmeW32wQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfef0cee4434a-EWR
+      - 8ab6b5db1bfd192c-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: '{"applyWithProfile":{"linkedIn":{"serviceAPIKey":"86eto2o4dqjyip","gadgetServerBaseURL":"https://applywithlinkedin.myworkdaygadgets.com","integrationContextId":"urn:li:organization:1771432","requireCookieAcceptance":false},"seek":{"advertiserId":"36467863"}},"analytics":{"googleUniversalAnalyticsID":"G-F1YSDPN56M"},"brandingData":{"progressBar":{"color":"#0066FF"},"button":{"primary":{"color":"#FF9933","borderColor":"#FF9933","textColor":"#FFFFFF","hover":{"color":"#E67300","borderColor":"#E67300","textColor":"#FFFFFF"}},"secondary":{"color":"#CCCCCC","borderColor":"#CCCCCC","textColor":"#000000","hover":{"color":"#999999","borderColor":"#999999","textColor":"#000000"}},"shape":"PILL"},"header":{"imageBanner":{"maintainAspectRatio":true},"banner":{"color":"#FFFFFF","borderColor":"#999999","textColor":"#000000","image":{"id":"8975f0c92a7d10015b8e9bf8009f0000"}}},"embedded":false},"chatbotConfiguration":{"paradoxWidgetToken":null},"configuredText":{"countryCustomLabel":"Country","countryPhoneCodeCustomLabel":"Country
-        Phone Code","introduceYourself":"Tell us About You","applyConfirmationMessage":"<p>Your
-        application has been submitted, thank you for your interest in Motorola Solutions!</p>"},"consentConfiguration":{"consentConfigurationVendor":{"id":"9de36ec94084100013e8560e84170000","descriptor":"Workday"},"oneTrustUrl":null},"facets":["jobFamilyGroup","locationCountry","distance","locations","timeType","timeType123"],"featureFlags":{"excludeSiteIndexing":false,"useAlternateCountryLabel":false,"accountVerification":false,"specialties":false,"preferredName":true,"skillsCloud":true,"candidateAccounts":true,"requireCandidateAccounts":true,"embedMode":false,"introduceYourself":true,"jobAlerts":true,"hideSearchForJobs":false},"footer":{"socialLinksList":[{"label":"Twitter","uri":"https://twitter.com/MotoSolutions"},{"label":"Facebook","uri":"https://www.facebook.com/MotorolaSolutions/"},{"label":"LinkedIn","uri":"https://www.linkedin.com/company/motorolasolutions/"}],"privacyPolicy":{"label":null,"uri":null}},"header":{"homePageURL":"https://www.motorolasolutions.com/en_us/about/careers.html","homeLinkText":"Careers","imageBannerUri":"/Careers/assets/banner","logoUri":"/Careers/assets/logo","cookieBanner":{"message":"<p><b><span>Motorola
+        Phone Code","applyConfirmationMessage":"<p>Your application has been submitted,
+        thank you for your interest in Motorola Solutions!</p>","introduceYourself":"Tell
+        us About You"},"consentConfiguration":{"consentConfigurationVendor":{"id":"9de36ec94084100013e8560e84170000","descriptor":"Workday"},"oneTrustUrl":null},"facets":["jobFamilyGroup","locationCountry","distance","locations","timeType","timeType123"],"featureFlags":{"accountVerification":false,"introduceYourself":true,"specialties":false,"jobAlerts":true,"hideSearchForJobs":false,"requireCandidateAccounts":true,"embedMode":false,"excludeSiteIndexing":false,"preferredName":true,"skillsCloud":true,"candidateAccounts":true,"useAlternateCountryLabel":false},"footer":{"socialLinksList":[{"label":"Twitter","uri":"https://twitter.com/MotoSolutions"},{"label":"Facebook","uri":"https://www.facebook.com/MotorolaSolutions/"},{"label":"LinkedIn","uri":"https://www.linkedin.com/company/motorolasolutions/"}],"privacyPolicy":{"label":null,"uri":null}},"header":{"homePageURL":"https://www.motorolasolutions.com/en_us/about/careers.html","homeLinkText":"Careers","imageBannerUri":"/Careers/assets/banner","logoUri":"/Careers/assets/logo","cookieBanner":{"message":"<p><b><span>Motorola
         Solutions values your privacy</span></b><br /><br /><span>Our website is set
         to allow cookies. We use cookies to improve your website experience, the products
         and services we offer and to make your digital experience personalized to
@@ -136,7 +137,7 @@ http_interactions:
         our </span><a href=\"https://motorolasolutions.com/en_xu/about/privacy-policy.html#cookies\"
         target=\"_blank\">Cookie Policy</a><span>.</span></p>","policy":"EVERYWHERE"}},"languages":[{"descriptor":"English","languageCode":"en_US"}],"mlEnabled":true,"recommendedJobsEnabled":true,"tenantDefaultCountry":{"id":"bc33aa3152ec42d4995f4791a106ed09","descriptor":"United
         States of America"},"toggles":["466d58ad03691000185ddce1282a0000","bc814e895c1d10000d1fd3354f4b0000","20ccbc6c60701000fafdc3dce74a0000","10f7a56eb11c100024a6d65b625a0000","547aef155f9510000b557900e89a0000","548d61215c4810001cce239053870000"]}'
-  recorded_at: Mon, 29 Jul 2024 09:13:57 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:26 GMT
 - request:
     method: post
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/jobs
@@ -158,7 +159,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:58 GMT
+      - Tue, 30 Jul 2024 16:26:27 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -172,335 +173,41 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=692e0bea0170e65a5c36a816fdc5c03bd38d02d3-instance=vps-prod-15lcvgiq.prod-vps.pr502.cust.pdx.wd;
+      - PLAY_SESSION=04fb8f3ca05a0a0af12602c170f738a5514313e8-instance=vps-prod-ctxjltrz.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=6P4jQ2DqplQEMzqTWHdxevsisY105XgoEqLqf69FI78-1722244438-1.0.1.1-BpRLGBU_AdWiqh4VFMmma9CbLSjsCxz3e8l2NHjJl7yQi4_Uv7X9V52zFIfgFsBfL51iIY1Q_HgF92ijxrvM6A;
-        path=/; expires=Mon, 29-Jul-24 09:43:58 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=2.j6YrHrSW7u9XCFcGW7dPWH7O3yhZSv0j.og5HSCjY-1722356787-1.0.1.1-CfDXsY8.Zg8_e2GiPRDSVwb.Bnt2S2FFs6xyLqrz3HldbzlB5NrYvivpuyvwyGZeVoToiq_kAmlc2YiIqe277Q;
+        path=/; expires=Tue, 30-Jul-24 16:56:27 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxfEWPscQuzHUnx; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:13:58 GMT; HttpOnly
-      - _cfuvid=bHsItaD0T6KvdQxqWGNRCdDn3oNElCWgPBw64d1R4pQ-1722244438316-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxenciHupmijiuS; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:27 GMT; HttpOnly
+      - _cfuvid=Q73IwmIydMxlnBbBgv7rOqgm9GdOp0JqsC97UGTk3_M-1722356787539-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=e24d58ca-6789-4ed3-b92f-e9fd13ccaf25; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=2230098954.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=c18de349-8030-4067-9967-799ecd163a3b; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=3840711690.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|b1d0f7c1-cce4-4551-b4fe-00dabfd0da51
+      - VPS|0732a733-5a15-4e6b-9af3-8c49310a6f70
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - DYNAMIC
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=hlvQXh11b9s2NO5zDel%2F689kfXlY4AvbO8vuJCuj1LxbTLmii%2Fr1jEPY8GwT9vNfk4MZBrSxiK0XvezPZQZ3L5qEMR7JVRYEyxXcm33AEOFhFuxlO2EozPfHwB7siO3LSOGAgE3HKPVlEK9PHl9ri0rfR5T9fQXcmg%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=U4rthVcPqmd93cZl8oty8HMnVP11oEGf0NIv935oYB8fO689FzqZM%2BEPO0nv3xs%2FCPyI8mbZdUJy8xYau4ZFzuELiBewfHsD%2F%2Fu3cndUMwQGQBlEI86gh79%2BcWv0N4DZcWSJvh7sAtvXznsMFUYTCj6uezfk9bmbhg%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfef6aa640f95-EWR
+      - 8ab6b5dea8440f69-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
-      string: '{"total":621,"jobPostings":[{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby,
-        UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48791","Rugby, UK
-        (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby,
-        UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48793","Rugby, UK
-        (ZUK107)"]},{"title":"Senior Technical Support Engineer (Edesix Mobile Video
-        APAC Region)","externalPath":"/job/Penang-Malaysia/Senior-Technical-Support-Engineer--Edesix-Mobile-Video-APAC-Region-_R48950","locationsText":"Penang,
-        Malaysia","postedOn":"Posted Today","bulletFields":["R48950","Penang, Malaysia
-        (ZMY33)"]},{"title":"Systems Integrations and Tests Engineer","externalPath":"/job/Krakow-Poland/Systems-Integrations-and-Tests-Engineer_R48671","locationsText":"Krakow,
-        Poland","postedOn":"Posted Today","bulletFields":["R48671","Krakow, Poland"]},{"title":"Senior
-        UX Designer","externalPath":"/job/Krakow-Poland/Senior-UX-Designer_R47040-1","locationsText":"Krakow,
-        Poland","postedOn":"Posted Today","bulletFields":["R47040","Krakow, Poland"]},{"title":"Software
-        Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48528","locationsText":"Bangalore,
-        India","postedOn":"Posted Today","bulletFields":["R48528","Bangalore, India
-        (ZIN110)"]},{"title":"Software Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48521","locationsText":"Bangalore,
-        India","postedOn":"Posted Today","bulletFields":["R48521","Bangalore, India
-        (ZIN110)"]},{"title":"SOC Analyst","externalPath":"/job/Schaumburg-IL/SOC-Analyst_R48874","locationsText":"Schaumburg,
-        IL","postedOn":"Posted Yesterday","bulletFields":["R48874","Schaumburg, IL
-        (IL01)"]},{"title":"Technical Triage Supervisor","externalPath":"/job/Reynosa-Mexico/Technical-Triage-Supervisor_R47739","locationsText":"Reynosa,
-        Mexico","postedOn":"Posted 3 Days Ago","bulletFields":["R47739","Reynosa,
-        Mexico (ZMX70)"]},{"title":"Senior Sales Engineer","externalPath":"/job/Pennsylvania-US-Offsite/Senior-Sales-Engineer_R48701","locationsText":"Pennsylvania,
-        US Offsite, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48701","Pennsylvania,
-        US Offsite (PA999)"]},{"title":"Director of Procurement","externalPath":"/job/Greater-Chicago-Area/Director-of-Procurement_R48891","locationsText":"Greater
-        Chicago Area, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48891","Greater
-        Chicago Area"]},{"title":"NOC Agent I","externalPath":"/job/Santiago-Chile/NOC-Agent-I_R48421","locationsText":"Santiago,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48421","Santiago,
-        Chile (ZCE10)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48725","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48725","Calama, Chile
-        (ZCE17)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48730","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48730","Calama, Chile
-        (ZCE17)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48729","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48729","Calama, Chile
-        (ZCE17)"]},{"title":"Portfolio Team Director","externalPath":"/job/Schaumburg-IL/Portfolio-Team-Director_R48414","locationsText":"Schaumburg,
-        IL, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48414","Schaumburg,
-        IL (IL01)"]},{"title":"Project Manager - Northeast Region Software Deployment
-        - US Remote","externalPath":"/job/New-Jersey-Remote-Work/Project-Manager---Northeast-Region-Software-Deployment---US-Remote_R48926","locationsText":"New
-        Jersey Remote Work, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48926","New
-        Jersey Remote Work"]},{"title":"Sales Manager","externalPath":"/job/Colorado-Remote-Work/Sales-Manager_R48640","locationsText":"Colorado
-        Remote Work","postedOn":"Posted 3 Days Ago","bulletFields":["R48640","Colorado
-        Remote Work"]},{"title":"Data Protection, Product Compliance Specialist -
-        Legal Support (US Remote)","externalPath":"/job/Chicago-IL/Data-Protection--Product-Compliance-Specialist---Legal-Support--US-Remote-_R48911-1","locationsText":"Chicago,
-        IL, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48911","Chicago,
-        IL (IL156)"]},{"title":"Quality Software Assurance Engineer","externalPath":"/job/Plantation-FL/Quality-Software-Assurance-Engineer_R48284","locationsText":"Plantation,
-        FL","postedOn":"Posted 3 Days Ago","bulletFields":["R48284","Plantation, FL
-        (FL08)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job
-        Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":294},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":89},{"descriptor":"Service
-        & Support","id":"c2197eea2758408bbbe52d2c04006230","count":81},{"descriptor":"Manufacturing
-        & Supply Chain","id":"5a650a685cb64a0ba694baa053e24bda","count":36},{"descriptor":"Information
-        Technology","id":"c3fc17b768e842e39b7192f0bf4cb0f1","count":32},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":28},{"descriptor":"Professional
-        Services","id":"60d771b675b201093e19718f600171af","count":18},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":17},{"descriptor":"General
-        Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":14},{"descriptor":"Administration
-        & Facilities","id":"0191c22da3ac417c94d450ccdb06a7ed","count":5},{"descriptor":"Legal
-        & Regulatory","id":"4170777a1c914320ad8828c0ec033c53","count":4},{"descriptor":"Human
-        Resources","id":"8e651d1131bc4aad9a089b555adc3975","count":3}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"North
-        America","id":"436f05d7afa343d5a8c9f92ef3e8c71b","count":187},{"descriptor":"Asia
-        Pacific","id":"14bb6aa2c25e4a218b2a3faaa951e44c","count":140},{"descriptor":"Europe
-        Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":116},{"descriptor":"Latin
-        America","id":"d6565dafd0ce4473932b0ce1ce9a0307","count":22}]},{"facetParameter":"timeType123","descriptor":"Time
-        Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":615},{"descriptor":"Part
-        time","id":"43259991a4cc42f1a7570dd5dc911e13","count":6}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":8},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":19},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":24},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":64},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":60},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":5},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":2},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":96},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":9},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Saudi
-        Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Taiwan","id":"a4e08b475d6a4176853c9d1cb9854e02","count":1},{"descriptor":"United
-        Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"United
-        Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":35},{"descriptor":"United
-        States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":227},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"Adelaide,
-        Australia","id":"84a18dcbc0d5453081ff0257c1ddc017","count":1},{"descriptor":"Alabama,
-        US Offsite","id":"bbb70e9710004203b5c0165259b19722","count":1},{"descriptor":"Alabama
-        Remote Work","id":"a2aa2501ee340139269db5448422f90a","count":2},{"descriptor":"Alberta
-        Remote Work","id":"a2aa2501ee3401ebad8800458422350b","count":2},{"descriptor":"Albuquerque,
-        NM (NM06)","id":"726d9bb69ca00184bc0a4eeaae18a9a7","count":2},{"descriptor":"Allen,
-        TX (TX139)","id":"a2aa2501ee340194a7e124312b23666e","count":22},{"descriptor":"Antofagasta,
-        Chile","id":"ff21797042291056c2292e32bd504b2e","count":1},{"descriptor":"Argentina
-        Offsite (ZAR99)","id":"5b4156247dd945009ecdd0815cc32261","count":2},{"descriptor":"Arizona,
-        US Offsite","id":"1427da907f71482e93d2ca9a94f4a721","count":19},{"descriptor":"Arizona
-        Remote Work","id":"a2aa2501ee3401172758a8448422ef0a","count":14},{"descriptor":"Arkansas
-        Remote Work","id":"a2aa2501ee340168512097448422e00a","count":1},{"descriptor":"Atlanta,
-        GA","id":"e6754dd8376744ae8810143cfdbd586b","count":1},{"descriptor":"Austria
-        Offsite (ZAT99)","id":"22cd4ef36d4410e861598876a5d8cdbe","count":2},{"descriptor":"Bangalore,
-        India","id":"dc87e0de602f103e7f08db009e1c78c9","count":54},{"descriptor":"Bangalore,
-        India (ZIN114)","id":"4114a9c5ddc5010679785ea9e8011a38","count":5},{"descriptor":"Bangalore
-        offsite, India","id":"83e4449f1df80133688024551401456f","count":3},{"descriptor":"Bay
-        Shore, NY (NY54)","id":"d879770ce580100165639203abdb0000","count":6},{"descriptor":"Beltsville,
-        MD","id":"ec2584050ebf102fb4ed7d77e3a0219e","count":5},{"descriptor":"Berlin,
-        Germany (ZWG172)","id":"da1bb7b30412011d12861db1754a47e2","count":4},{"descriptor":"Birmingham,
-        AL","id":"37cbf3aa4d9810d6aa793a34d460121d","count":1},{"descriptor":"Bogota,
-        Colombia (ZCL04)","id":"4e4bade28097445dbdf1e9acd5883db8","count":2},{"descriptor":"Brazil
-        Offsite","id":"31e50f098c28482282d16915b1f03b02","count":1},{"descriptor":"Brazil
-        Remote Work","id":"a2aa2501ee3401046547064584223a0b","count":14},{"descriptor":"British
-        Columbia,CAN Offsite","id":"99abf5d326b8405d913f070afd962314","count":2},{"descriptor":"British
-        Columbia Remote Work","id":"a2aa2501ee3401529baefa448422300b","count":2},{"descriptor":"Buenos
-        Aires, Ar - bus cntr (ZAR20)","id":"82f5b0bf5d18014fe0aa2c9b8f01e376","count":2},{"descriptor":"Bulgaria
-        Offsite (ZBU99)","id":"b20e212a792d4ebba04149117d379262","count":3},{"descriptor":"Burswood,
-        Australia","id":"315987c1b99841a2a788d8e7f09c3e85","count":1},{"descriptor":"Cairo,
-        Egypt","id":"27419f4f50f31074bf6d12933928093d","count":1},{"descriptor":"Calama,
-        Chile","id":"5add0ac80d6801f6eb698aeb780d6d24","count":3},{"descriptor":"California
-        Northern, US Offsite","id":"51094660fa0a4ec4b328886f73a854d2","count":5},{"descriptor":"California
-        Northern Remote Work","id":"a2aa2501ee34015666cf5f448422b30a","count":11},{"descriptor":"California
-        Southern, US Offsite","id":"2e27a5a31dfb43d6b1fe21b8f268733c","count":6},{"descriptor":"California
-        Southern Remote Work","id":"a2aa2501ee34016f686b59448422ae0a","count":13},{"descriptor":"Charlotte,
-        NC","id":"09f65edec644100fb96d7a9a30a7de0e","count":1},{"descriptor":"Chicago,
-        IL","id":"56b899ac82d3102ebb10086c343f0eed","count":44},{"descriptor":"Chile
-        Remote Work","id":"a2aa2501ee340133264bcf4484220d0b","count":1},{"descriptor":"Colorado,
-        US Offsite","id":"14ab7340d6e645c1827628a28827563a","count":1},{"descriptor":"Colorado
-        Remote Work","id":"a2aa2501ee34015a1230464484229f0a","count":9},{"descriptor":"Connecticut,
-        US Offsite","id":"399e74c7d2c4436ea401e45369f54a9c","count":3},{"descriptor":"Connecticut
-        Remote Work","id":"a2aa2501ee3401d887c339448422950a","count":2},{"descriptor":"Cork,
-        Ireland","id":"61b9ddf3a0c51000b136358fdbcb0000","count":1},{"descriptor":"Cork,
-        Ireland - Business CNTR (ZEI16)","id":"e8aed7fb96be1000b4bd44c6150c0000","count":29},{"descriptor":"Culver
-        City, CA","id":"f2cb61a1d06a01e3044baadd1f01ba77","count":7},{"descriptor":"Dallas,
-        TX","id":"d0be8406d7eb0108618092b78c8c3d7d","count":3},{"descriptor":"Dallas,
-        TX (TX143)","id":"61b9ddf3a0c51000b1184fb114ed0000","count":1},{"descriptor":"Delaware,
-        US Offsite","id":"fdbba75aa4044c649cf4ddd888004e1e","count":8},{"descriptor":"Delaware
-        Remote Work","id":"a2aa2501ee3401860b4433448422900a","count":5},{"descriptor":"Dubai,
-        UAE","id":"7dda71e222860100aa71137f4c680000","count":2},{"descriptor":"Eagan,
-        MN","id":"45632196659f01ded4d69952ac36dd7a","count":1},{"descriptor":"Edinburgh,
-        UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Elgin,
-        IL","id":"56b899ac82d3102ebe1e9ed8fc6722d7","count":1},{"descriptor":"Farmington
-        Hills, MI (MI17)","id":"da1bb7b3041201d56bf55c9f774a95e3","count":1},{"descriptor":"Florida,
-        US Offsite","id":"024e19ecdef743ea8576fd1f592a479c","count":22},{"descriptor":"Florida
-        Remote Work","id":"a2aa2501ee34015d6ddb26478422fd0c","count":24},{"descriptor":"Fornebu,
-        Norway (ZNO11)","id":"ba927ad987ee01020389e6b494000000","count":1},{"descriptor":"Fort
-        Collins, CO (CO29)","id":"4114a9c5ddc501787dea77fde7019936","count":2},{"descriptor":"Fort
-        Worth, TX (TX135)","id":"731a6d25b4bc01260a2ef4efbe0b4e60","count":2},{"descriptor":"Framingham,
-        MA","id":"442a24924422100157ed1e5a4c5c0000","count":1},{"descriptor":"Fresno,
-        CA (CA180)","id":"4114a9c5ddc501232fd3ac42e7010636","count":2},{"descriptor":"Ft.
-        Lauderdale, FL (FL87)","id":"da5e91a4328101abe15bda8ec823a9bc","count":2},{"descriptor":"Georgia,
-        US Offsite","id":"f1180d181cc140dba59dd0e993a002f1","count":14},{"descriptor":"Georgia
-        Remote Work","id":"a2aa2501ee3401b67a9904478422df0c","count":14},{"descriptor":"Germany
-        Offsite (ZWG99)","id":"5c1aee55369b44a2a5136da8dec8e315","count":6},{"descriptor":"Glasgow,
-        UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Glostrup,
-        Denmark (ZDK02)","id":"27a1c404f5744ae68442996960fe2804","count":3},{"descriptor":"Greater
-        Chicago Area","id":"a2aa2501ee34015128ebf2468422d00c","count":15},{"descriptor":"Greater
-        Dallas Area","id":"a2aa2501ee34013ba7b67b4584229a0b","count":1},{"descriptor":"Greater
-        Krakow Area","id":"a2aa2501ee3401e68a4c96478422610d","count":1},{"descriptor":"Gurgaon,
-        India","id":"d879770ce5801001ba2441f0f8260000","count":4},{"descriptor":"Hemel
-        Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1},{"descriptor":"Ho
-        Chi Minh, Vietnam","id":"04fbb808deef1000aba4980e9ce60000","count":2},{"descriptor":"Ho
-        Chi Minh City, Vietnam (ZVI16)","id":"da5e91a4328101b8bd368cee2324adf1","count":1},{"descriptor":"Idaho
-        Remote Work","id":"a2aa2501ee3401e0c730f9468422d50c","count":2},{"descriptor":"Idstein,
-        Germany (ZWG86)","id":"04a42199937044bbbf6010ed72d1d007","count":2},{"descriptor":"Illinois,
-        US Offsite","id":"037ebcbfd6ee4ad8a96ca2f9ec955366","count":33},{"descriptor":"Illinois
-        Remote Work","id":"a2aa2501ee3401b4149aec468422cb0c","count":28},{"descriptor":"Indiana,
-        US Offsite","id":"86ac456645c1476581ccafcdabd07091","count":10},{"descriptor":"Indianapolis,
-        IN","id":"7f977422e7ba456a98281fb6d502202e","count":1},{"descriptor":"Indiana
-        Remote Work","id":"a2aa2501ee3401181c56e6468422c60c","count":15},{"descriptor":"India
-        Offsite (ZIN99)","id":"801ee26ff10b4e2389d3a9d125e02ae3","count":2},{"descriptor":"Iowa,
-        US Offsite","id":"1787eed6fea6446f9bc1036e9a5962d9","count":1},{"descriptor":"Iowa
-        Remote Work","id":"a2aa2501ee34012b9d0fda468422bc0c","count":7},{"descriptor":"Italy
-        Offsite (ZIT99)","id":"7de50b13083047dfb5400de1b3b32aba","count":1},{"descriptor":"Kansas,
-        US Offsite","id":"061f9780eeaf4ab392eb38562e8635c0","count":4},{"descriptor":"Kansas
-        Remote Work","id":"a2aa2501ee3401a115bcd4468422b70c","count":5},{"descriptor":"Kentucky,
-        US Offsite","id":"5e9d2bcbc1df436db79c28a492f83838","count":2},{"descriptor":"Kentucky
-        Remote Work","id":"a2aa2501ee340110c46bcf468422b20c","count":2},{"descriptor":"Krakow,
-        Poland","id":"cdb6c301cead01c0fd6255fbbe0073b9","count":90},{"descriptor":"Krakow,
-        Poland","id":"30c4e7f824bd4b1a892b4ee4a537c2f7","count":2},{"descriptor":"Krakow,
-        Poland","id":"3cc51f087f9747d5b0b2af9d001b0281","count":1},{"descriptor":"Kuala
-        Lumpur, Malaysia","id":"817fef2f26ad4eec85f3d1f59f67a08c","count":2},{"descriptor":"Lexington,
-        SC (SC07)","id":"da5e91a43281017cec012a9ab8239ba2","count":1},{"descriptor":"Linthicum,
-        MD","id":"c152d08a5f9c104eed32617c8087529c","count":3},{"descriptor":"Lisbon,
-        Portugal","id":"d0be8406d7eb01df5699f9468d8cf97d","count":8},{"descriptor":"Lisbon,
-        Portugal","id":"60d771b675b201dd1b8cf4a90e01c534","count":1},{"descriptor":"Little
-        Rock, AR","id":"9294dc0527c54192b5c8338f762402d1","count":1},{"descriptor":"London,
-        UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":4},{"descriptor":"Los
-        Angeles, CA","id":"75eeec0cd30c4823b7cdbc46c87436e3","count":1},{"descriptor":"Los
-        Angeles, CA","id":"20b991fa96e9475db727dbe3c7df1156","count":1},{"descriptor":"Louisiana
-        Remote Work","id":"a2aa2501ee340134851ac4468422a80c","count":1},{"descriptor":"Madrid,
-        Spain","id":"8cfc0951b3b94bd98139c963eb68ec99","count":2},{"descriptor":"Maine,
-        US Offsite","id":"992c04fd1a9c41d3a6a904ffe0de680c","count":3},{"descriptor":"Maine
-        Remote Work","id":"a2aa2501ee34019d8ee2b74684229e0c","count":5},{"descriptor":"Manitoba
-        Remote Work","id":"a2aa2501ee3401b8f6e9f44484222b0b","count":3},{"descriptor":"Maryland,
-        US Offsite","id":"b83767d4324c46c999f575fd542abd88","count":16},{"descriptor":"Maryland
-        Remote Work","id":"a2aa2501ee3401dbf94bb2468422990c","count":18},{"descriptor":"Massachusetts,
-        US Offsite","id":"ef9ff0866473431aa0807077edea046d","count":18},{"descriptor":"Massachusetts
-        Remote Work","id":"a2aa2501ee340136dff99f4684228a0c","count":12},{"descriptor":"Melbourne,
-        Australia","id":"d7e3ba3b107b442382576d564fcbadfd","count":2},{"descriptor":"Mexico
-        City, Mexico","id":"2b254088ddb54694997bd94b011e140c","count":4},{"descriptor":"Mexico
-        Offsite","id":"5ef0f2a16491016a2dbdefc5034f5d9c","count":1},{"descriptor":"Michigan,
-        US Offsite","id":"4b3514833681469ba0b512c446b25b97","count":10},{"descriptor":"Michigan
-        Remote Work","id":"a2aa2501ee3401621d8898468422830c","count":9},{"descriptor":"Minnesota,
-        US Offsite","id":"efb7395e01e54bde949ac224af8f56a6","count":3},{"descriptor":"Minnesota
-        Remote Work","id":"a2aa2501ee34018daff981468422740c","count":5},{"descriptor":"Mississippi
-        Remote Work","id":"a2aa2501ee340143de0a7c4684226f0c","count":2},{"descriptor":"Missouri,
-        US Offsite","id":"fb75ff372ac14e1b809a1dd53333021e","count":2},{"descriptor":"Missouri
-        Remote Work","id":"a2aa2501ee340123e99d6f468422650c","count":4},{"descriptor":"Montana
-        Remote Work","id":"a2aa2501ee3401c92dfa69468422600c","count":1},{"descriptor":"Morocco
-        Offsite (ZMO99)","id":"13183554e71d4ea3b51cc01fb4310a38","count":1},{"descriptor":"Muscat,
-        Oman","id":"7af2294c87014d38b73cc1f8e8046db2","count":1},{"descriptor":"Nebraska
-        Remote Work","id":"a2aa2501ee3401c3ed27644684225b0c","count":1},{"descriptor":"Nevada,
-        US Offsite","id":"63ba34e24ce44a5d92912e0cadae491c","count":1},{"descriptor":"Nevada
-        Remote Work","id":"a2aa2501ee34015e595a5e468422560c","count":2},{"descriptor":"New
-        Hampshire, US Offsite","id":"0727cec59d1544888ff072b50e96a1c3","count":5},{"descriptor":"New
-        Hampshire Remote Work","id":"a2aa2501ee3401e10a2558468422510c","count":3},{"descriptor":"Newington,
-        VA","id":"a2d68824ae0f4fdfa99ac487376a60c0","count":1},{"descriptor":"New
-        Jersey, US Offsite","id":"dd456a04291641a5b02b5731f3e70d4a","count":9},{"descriptor":"New
-        Jersey Remote Work","id":"a2aa2501ee340154abd2524684224c0c","count":14},{"descriptor":"New
-        Mexico, US Offsite","id":"0bf30a8368014b0e90cd36a3c4d20e1a","count":2},{"descriptor":"New
-        Mexico Remote Work","id":"a2aa2501ee3401cff79a46468422420c","count":3},{"descriptor":"New
-        York, US Offsite","id":"3f76dd361d8b410784ca4fc8dc2421f7","count":8},{"descriptor":"New
-        York Remote Work","id":"a2aa2501ee34015fb0b438468422380c","count":11},{"descriptor":"North
-        Carolina, US Offsite","id":"2080bb98030b4515ba37427d91ff32cc","count":13},{"descriptor":"North
-        Carolina Remote Work","id":"a2aa2501ee34015223b220468422210c","count":15},{"descriptor":"North
-        Dakota, US Offsite","id":"a9996a2fd97f4d3e95a330c9526ec0b3","count":1},{"descriptor":"North
-        Dakota Remote Work","id":"a2aa2501ee3401842df90e468422120c","count":3},{"descriptor":"NSW
-        Offsite, Australia","id":"8e1edfbe285b1063341996ac3138c4ca","count":1},{"descriptor":"Offsite
-        France (ZFR99)","id":"71f31ba331b642f3a3ae05b211a469d1","count":1},{"descriptor":"Ohio,
-        US Offsite","id":"c9f53b4342e94035b77570cfe5599af6","count":15},{"descriptor":"Ohio
-        Remote Work","id":"a2aa2501ee34011ff5ccfc458422030c","count":12},{"descriptor":"Oklahoma,
-        US Offsite","id":"7ceb761aa15d46d7b6c9a6bb4d05c509","count":4},{"descriptor":"Oklahoma
-        Remote Work","id":"a2aa2501ee3401d33bbaf6458422fe0b","count":4},{"descriptor":"ONT39","id":"5c4e189f92a610016f2ffc6e5c630000","count":3},{"descriptor":"Ontario
-        Remote Work","id":"a2aa2501ee340179e5f7e8448422210b","count":10},{"descriptor":"Oregon,
-        US Offsite","id":"746c5cc1f07d48d7837f3db4895a18e7","count":9},{"descriptor":"Oregon
-        Remote Work","id":"a2aa2501ee3401d4d45ff0458422f90b","count":5},{"descriptor":"Orlando,
-        FL","id":"b7c95ddf5a041015a61c88e160676351","count":2},{"descriptor":"Oslo,
-        Norway (ZNO07)","id":"8ef71253a56d4aaf92ff5a5364ccc8ac","count":1},{"descriptor":"Ottawa,
-        Canada","id":"77e555f21e5501db407373e92a70fa79","count":1},{"descriptor":"Parma,
-        OH","id":"9efafca5ae9041f7980582836384f807","count":1},{"descriptor":"Penang,
-        Malaysia","id":"c6d7e2b64f8b107f215186f1d658a224","count":58},{"descriptor":"Penang,
-        Malaysia","id":"8dfc527f8ed44cee87fe36c1afbaf264","count":1},{"descriptor":"Penang,
-        Malaysia","id":"168b0d8a3214463583f95156388faf2d","count":1},{"descriptor":"Pennsylvania,
-        US Offsite","id":"89941ac3741f436ab4e333e49a8fba84","count":16},{"descriptor":"Pennsylvania
-        Remote Work","id":"a2aa2501ee3401fe0c4ed8458422e50b","count":12},{"descriptor":"Plantation,
-        FL","id":"17ba885223814f9ab57dedd1e725b00a","count":8},{"descriptor":"Plantation,
-        FL","id":"d879770ce5801001b9b947c3860f0000","count":1},{"descriptor":"Poland
-        Offsite (ZPL99)","id":"9587715495c14b2b946ee753f5adba22","count":8},{"descriptor":"Portugal
-        Offsite (ZPT99)","id":"22e48e01af704af5acf68a768e1184ed","count":1},{"descriptor":"Puerto
-        Rico Offsite","id":"c35e2c7bf9b1444bb4c00699df114d76","count":1},{"descriptor":"Quebec
-        Remote Work","id":"a2aa2501ee34017ab529dc448422170b","count":6},{"descriptor":"Reynosa,
-        Mexico","id":"2cc4589d2ab01001021366bdbd430000","count":1},{"descriptor":"Rhode
-        Island, US Offsite","id":"75ccaab07ff843b4bb5433ed70cbaff7","count":4},{"descriptor":"Rhode
-        Island Remote Work","id":"a2aa2501ee34018f99a6c6458422d60b","count":1},{"descriptor":"Richardson,
-        TX (TX141)","id":"a1b4b9c5b61b016ad44e1b6108028e25","count":1},{"descriptor":"Richmond,
-        VA","id":"9ea53914b84d01586593035807010e1b","count":1},{"descriptor":"Riyadh,
-        Saudi Arabia","id":"dfff2595c3404fe89fcea0c4a139065c","count":2},{"descriptor":"Romania
-        Offsite (ZRO99)","id":"88268c4ae43b48c1bd5baa7007a31a71","count":1},{"descriptor":"Rugby,
-        UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Sacramento,
-        CA","id":"c4ee93d3538249b29c9fb0bfde3295be","count":1},{"descriptor":"San
-        Mateo, CA","id":"3955e91ab9be1000d6a5f34dfd560000","count":1},{"descriptor":"Santiago,
-        Chile","id":"ff21797042291056c1ed919d43474a6f","count":2},{"descriptor":"Santiago,
-        Chile","id":"ff21797042291056c2a0d44e6f564d8b","count":1},{"descriptor":"Sao
-        Paulo, Brazil","id":"d234454abe5110015dd3a0c5bb570000","count":4},{"descriptor":"Sarasota,
-        FL","id":"279a8a3ddd4d018ef74c6ecba500157e","count":1},{"descriptor":"Saskatchewan
-        Remote Work","id":"a2aa2501ee34019300f5d5448422120b","count":3},{"descriptor":"Schaumburg,
-        IL","id":"5983637b827e4ed097966aa984c7cf6c","count":9},{"descriptor":"Schaumburg,
-        IL","id":"f90bd5bcf3df4205a301db42c4557bdd","count":1},{"descriptor":"Schio,
-        Italy","id":"a66ea95a586801014b0a39c8aa730000","count":1},{"descriptor":"Singapore,
-        Singapore","id":"914a4f61913c10357f56e7fd0de4f904","count":1},{"descriptor":"Singapore,
-        Singapore (ZSG38)","id":"c6d7e2b64f8b107f233884cad328a5a5","count":1},{"descriptor":"Somerville,
-        MA","id":"d0be8406d7eb01197d6786d18c8c617d","count":2},{"descriptor":"South
-        Carolina, US Offsite","id":"4548f2167eca45daaa61d7c4aa7d08da","count":2},{"descriptor":"South
-        Carolina Remote Work","id":"a2aa2501ee3401ac594eb9458422cc0b","count":10},{"descriptor":"South
-        Dakota, US Offsite","id":"520ca850ee1443438ff88ea729c5dc1f","count":1},{"descriptor":"South
-        Dakota Remote Work","id":"a2aa2501ee3401e9b731b3458422c70b","count":2},{"descriptor":"Spain
-        Offsite (ZES99)","id":"301a357729b94516a34e3a61a35c1bb5","count":1},{"descriptor":"St.
-        Petersburg, FL (FL92)","id":"4114a9c5ddc501b041023c10a301a7b6","count":1},{"descriptor":"Sterling,
-        VA","id":"ca833823055501ee67c0d0e6ff01d6ee","count":1},{"descriptor":"St Petersburg,
-        FL","id":"b9d0a434256f01442efa8db524cf8e23","count":1},{"descriptor":"Switzerland
-        Offsite (ZSW99)","id":"bc6c8eecc49e4078ac65cd83165d02c5","count":1},{"descriptor":"Sydney,
-        Australia (ZAS102)","id":"a161ce532f951001110b54a8d1f80000","count":1},{"descriptor":"Taguig,
-        Philippines","id":"c6c7d41a752501ed42def116f4000e0e","count":2},{"descriptor":"Taipei,
-        Taiwan (ZTW27)","id":"d5ae1f500ea90178bf268aa77a2ef6bc","count":1},{"descriptor":"Tennessee,
-        US Offsite","id":"aa9f12002a984c16858ff0b2be54fce4","count":14},{"descriptor":"Tennessee
-        Remote Work","id":"a2aa2501ee3401a15dcfac458422c20b","count":13},{"descriptor":"Texas,
-        US Offsite","id":"7951f208c4a44af291de95d7063ca8ea","count":33},{"descriptor":"Texas
-        Remote Work","id":"a2aa2501ee3401bb3ac08d458422a90b","count":25},{"descriptor":"Tokyo,
-        Japan","id":"8c4c7f50760701262d4b1accf800fb4f","count":1},{"descriptor":"Toronto,
-        Canada (ONT40)","id":"442a249244221001582c47e270eb0000","count":6},{"descriptor":"United
-        Arab Emirates Offsite (ZUA99)","id":"dcc3bd6cdddc4454ad3336c2520953a5","count":1},{"descriptor":"United
-        Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":21},{"descriptor":"Utah,
-        US Offsite","id":"f61b91f41da34642ae840d013eb6ec7d","count":18},{"descriptor":"Utah
-        Remote Work","id":"a2aa2501ee3401463afc6e458422900b","count":10},{"descriptor":"Uxbridge,
-        UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Vancouver,
-        Canada","id":"d0be8406d7eb01e1ef6d1c418c8cf679","count":7},{"descriptor":"Vermont
-        Remote Work","id":"a2aa2501ee3401d6729461458422840b","count":3},{"descriptor":"Versailles,
-        France","id":"7dda71e222860100ab254c24897f0000","count":1},{"descriptor":"Vienna,
-        Austria","id":"46a2113a7c421062bd06fb72dee26f45","count":1},{"descriptor":"Virginia,
-        US Offsite","id":"c6987245ed6b4552b729aa8ca40c084f","count":16},{"descriptor":"Virginia
-        Remote Work","id":"a2aa2501ee3401aefdf55a4584227f0b","count":12},{"descriptor":"Ware,
-        UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Warsaw,
-        Poland","id":"d4e8b75046371067ca56ac231068e8e9","count":2},{"descriptor":"Warsaw,
-        Poland","id":"c3422e7a11fd466e8a10d70edc3171ce","count":2},{"descriptor":"Washington,
-        US Offsite","id":"0270f0ddaa9c4df780efe79b9477a4dc","count":5},{"descriptor":"Washington
-        DC, US Offsite","id":"6703b0349e294f7982d1105b4180e6bf","count":4},{"descriptor":"Washington
-        DC Remote Work","id":"a2aa2501ee34012ca4a4274484228b0a","count":6},{"descriptor":"Washington
-        Remote Work","id":"a2aa2501ee3401c3bf02344584225d0b","count":9},{"descriptor":"Westminster,
-        CO","id":"435c641825b8436a950f0c3c604cc62e","count":1},{"descriptor":"West
-        Valley City, UT","id":"dc4b44bb9c9210367f2102c8f37b8c34","count":1},{"descriptor":"West
-        Virginia, US Offsite","id":"41c94f5726b54db19a40ed8ab4c7016f","count":1},{"descriptor":"West
-        Virginia Remote Work","id":"a2aa2501ee3401a5c1d62d458422580b","count":3},{"descriptor":"Wisconsin,
-        US Offsite","id":"e350deb449e548d7be5c7185f399be05","count":2},{"descriptor":"Wisconsin
-        Remote Work","id":"a2aa2501ee340159152027458422530b","count":10},{"descriptor":"Woodcliff
-        Lake, NJ","id":"56b899ac82d3102ebddb9e5d99cf2205","count":1},{"descriptor":"Wyoming,
-        US Offsite","id":"857b68215cb8413f8fc0085cc2df67b3","count":1},{"descriptor":"Wyoming
-        Remote Work","id":"a2aa2501ee3401412f02214584224e0b","count":4},{"descriptor":"ZAS100","id":"20a50c646bd31001a8ec21fd6d5f0000","count":2}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10
-        miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25
-        miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50
-        miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100
-        miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any
-        Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}'
-  recorded_at: Mon, 29 Jul 2024 09:13:58 GMT
+      string: !binary |-
+        {"total":622,"jobPostings":[{"title":"Business and Data Analytics - 2024 Fall Co-Op","externalPath":"/job/Allen-TX-TX139/Business-and-Data-Analytics---2024-Fall-Co-Op_R48967","locationsText":"Allen, TX (TX139)","postedOn":"Posted Today","bulletFields":["R48967","Allen, TX (TX139)"]},{"title":"Channel Sales Executive - Video Security & Access Control (Dallas)","externalPath":"/job/Dallas-TX/Channel-Sales-Executive---Video-Security---Access-Control--Dallas-_R48932","locationsText":"Dallas, TX, More...","postedOn":"Posted Today","bulletFields":["R48932","Dallas, TX (TX133)"]},{"title":"VS&A Product Sales Specialist - Pelco (Southeast)","externalPath":"/job/Ft-Lauderdale-FL-FL87/VS-A-Product-Sales-Specialist---Pelco--Southeast-_R48680-1","locationsText":"Ft. Lauderdale, FL (FL87), More...","postedOn":"Posted Today","bulletFields":["R48680","Ft. Lauderdale, FL (FL87)"]},{"title":"VS&A Product Sales Specialist - Pelco (Northeast)","externalPath":"/job/Framingham-MA/VS-A-Product-Sales-Specialist---Pelco--Northeast-_R48679-1","locationsText":"Framingham, MA, More...","postedOn":"Posted Today","bulletFields":["R48679","Framingham, MA (MA52)"]},{"title":"VS&A Product Sales Specialist - Pelco (West)","externalPath":"/job/Phoenix-AZ/VS-A-Product-Sales-Specialist---Pelco--West-_R48678-1","locationsText":"Phoenix, AZ, More...","postedOn":"Posted Today","bulletFields":["R48678","Phoenix, AZ (AZ93)"]},{"title":"VS&A Product Sales Specialist - Pelco (Central)","externalPath":"/job/Illinois-US-Offsite/VS-A-Product-Sales-Specialist---Pelco--Central-_R48677-1","locationsText":"Illinois, US Offsite, More...","postedOn":"Posted Today","bulletFields":["R48677","Illinois, US Offsite (IL999)"]},{"title":"Software Developer","externalPath":"/job/Bangalore-offsite-India/Software-Developer_R48966","locationsText":"Bangalore offsite, India","postedOn":"Posted Today","bulletFields":["R48966","Bangalore offsite, India (ZIN125)"]},{"title":"Avigilon Business Development Manager, A&E , West Region","externalPath":"/job/California-Northern-Remote-Work/Avigilon-Business-Development-Manager--A-E---West-Region_R48885","locationsText":"California Northern Remote Work, More...","postedOn":"Posted Today","bulletFields":["R48885","California Northern Remote Work"]},{"title":"Junior Order Management Coordinator (mixed shift)","externalPath":"/job/Krakow-Poland/Junior-Order-Management-Coordinator--mixed-shift-_R48896","locationsText":"Krakow, Poland","postedOn":"Posted Today","bulletFields":["R48896","Krakow, Poland"]},{"title":"Responsable support client / Customer Support Manager","externalPath":"/job/Versailles-France/Customer-Support-Manager_R48390","locationsText":"Versailles, France","postedOn":"Posted Today","bulletFields":["R48390","Versailles, France (ZFR49)"]},{"title":"Solutions Architect (US REMOTE)","externalPath":"/job/Colorado-Remote-Work/Sr-Solutions-Architect--US-REMOTE-_R48655","locationsText":"Colorado Remote Work, More...","postedOn":"Posted Today","bulletFields":["R48655","Colorado Remote Work"]},{"title":"Manager Software Engineering","externalPath":"/job/Bangalore-India/Manager-Software-Engineering_R47328","locationsText":"Bangalore, India","postedOn":"Posted Today","bulletFields":["R47328","Bangalore, India (ZIN110)"]},{"title":"Estágio em Gerenciamento de Projetos","externalPath":"/job/Sao-Paulo-Brazil/Estgio-em-Gerenciamento-de-Projetos_R48964","locationsText":"Sao Paulo, Brazil","postedOn":"Posted Today","bulletFields":["R48964","Sao Paulo, Brazil (ZBR48)"]},{"title":"Junior Systems Engineer","externalPath":"/job/Lisbon-Portugal/Junior-Systems-Engineer_R48482","locationsText":"Lisbon, Portugal","postedOn":"Posted Today","bulletFields":["R48482","Lisbon, Portugal (ZPT16)"]},{"title":"Software Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48827","locationsText":"Bangalore, India","postedOn":"Posted Today","bulletFields":["R48827","Bangalore, India (ZIN110)"]},{"title":"Senior Electrical Engineer (RF)","externalPath":"/job/Penang-Malaysia/Senior-Electrical-Engineer--RF-_R45891","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R45891","Penang, Malaysia (ZMY33)"]},{"title":"Software Engineer","externalPath":"/job/Penang-Malaysia/Software-Engineer_R48238","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R48238","Penang, Malaysia (ZMY33)"]},{"title":"Quality Specialist","externalPath":"/job/ZAS100/Quality-Specialist_R46952-1","locationsText":"ZAS100","postedOn":"Posted Today","bulletFields":["R46952","Perth, Australia (ZAS100)"]},{"title":"Senior Field Service Support Engineer","externalPath":"/job/Seoul-Korea/Senior-Field-Service-Support-Engineer_R48271","locationsText":"Seoul, Korea","postedOn":"Posted Today","bulletFields":["R48271","Seoul, Korea (ZKR44)"]},{"title":"Software Engineer","externalPath":"/job/Penang-Malaysia/Software-Engineer_R48236","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R48236","Penang, Malaysia (ZMY33)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":290},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":92},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":84},{"descriptor":"Manufacturing & Supply Chain","id":"5a650a685cb64a0ba694baa053e24bda","count":36},{"descriptor":"Information Technology","id":"c3fc17b768e842e39b7192f0bf4cb0f1","count":29},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":28},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":20},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":18},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":13},{"descriptor":"Administration & Facilities","id":"0191c22da3ac417c94d450ccdb06a7ed","count":6},{"descriptor":"Legal & Regulatory","id":"4170777a1c914320ad8828c0ec033c53","count":3},{"descriptor":"Human Resources","id":"8e651d1131bc4aad9a089b555adc3975","count":3}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"North America","id":"436f05d7afa343d5a8c9f92ef3e8c71b","count":195},{"descriptor":"Asia Pacific","id":"14bb6aa2c25e4a218b2a3faaa951e44c","count":131},{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":117},{"descriptor":"Latin America","id":"d6565dafd0ce4473932b0ce1ce9a0307","count":24}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":613},{"descriptor":"Part time","id":"43259991a4cc42f1a7570dd5dc911e13","count":9}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":5},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":21},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":23},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":61},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1},{"descriptor":"Korea, Republic of","id":"7a5a2aadf9d34086a2bfbfd408bc28da","count":1},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":58},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":6},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":1},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":94},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":10},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":34},{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":236},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"Alabama, US Offsite","id":"bbb70e9710004203b5c0165259b19722","count":1},{"descriptor":"Alabama Remote Work","id":"a2aa2501ee340139269db5448422f90a","count":1},{"descriptor":"Alberta Remote Work","id":"a2aa2501ee3401ebad8800458422350b","count":2},{"descriptor":"Albuquerque, NM (NM06)","id":"726d9bb69ca00184bc0a4eeaae18a9a7","count":2},{"descriptor":"Allen, TX (TX139)","id":"a2aa2501ee340194a7e124312b23666e","count":22},{"descriptor":"Antofagasta, Chile","id":"ff21797042291056c2292e32bd504b2e","count":1},{"descriptor":"Argentina Offsite (ZAR99)","id":"5b4156247dd945009ecdd0815cc32261","count":2},{"descriptor":"Arizona, US Offsite","id":"1427da907f71482e93d2ca9a94f4a721","count":20},{"descriptor":"Arizona Remote Work","id":"a2aa2501ee3401172758a8448422ef0a","count":14},{"descriptor":"Arkansas Remote Work","id":"a2aa2501ee340168512097448422e00a","count":2},{"descriptor":"Atlanta, GA","id":"e6754dd8376744ae8810143cfdbd586b","count":1},{"descriptor":"Austria Offsite (ZAT99)","id":"22cd4ef36d4410e861598876a5d8cdbe","count":2},{"descriptor":"Bangalore, India","id":"dc87e0de602f103e7f08db009e1c78c9","count":50},{"descriptor":"Bangalore, India (ZIN114)","id":"4114a9c5ddc5010679785ea9e8011a38","count":5},{"descriptor":"Bangalore offsite, India","id":"83e4449f1df80133688024551401456f","count":4},{"descriptor":"Bay Shore, NY (NY54)","id":"d879770ce580100165639203abdb0000","count":6},{"descriptor":"Beltsville, MD","id":"ec2584050ebf102fb4ed7d77e3a0219e","count":5},{"descriptor":"Berlin, Germany (ZWG172)","id":"da1bb7b30412011d12861db1754a47e2","count":4},{"descriptor":"Birmingham, AL","id":"37cbf3aa4d9810d6aa793a34d460121d","count":1},{"descriptor":"Bogota, Colombia (ZCL04)","id":"4e4bade28097445dbdf1e9acd5883db8","count":2},{"descriptor":"Brazil Offsite","id":"31e50f098c28482282d16915b1f03b02","count":1},{"descriptor":"Brazil Remote Work","id":"a2aa2501ee3401046547064584223a0b","count":15},{"descriptor":"British Columbia,CAN Offsite","id":"99abf5d326b8405d913f070afd962314","count":2},{"descriptor":"British Columbia Remote Work","id":"a2aa2501ee3401529baefa448422300b","count":2},{"descriptor":"Buenos Aires, Ar - bus cntr (ZAR20)","id":"82f5b0bf5d18014fe0aa2c9b8f01e376","count":2},{"descriptor":"Bulgaria Offsite (ZBU99)","id":"b20e212a792d4ebba04149117d379262","count":3},{"descriptor":"Cairo, Egypt","id":"27419f4f50f31074bf6d12933928093d","count":1},{"descriptor":"Calama, Chile","id":"5add0ac80d6801f6eb698aeb780d6d24","count":3},{"descriptor":"California Northern, US Offsite","id":"51094660fa0a4ec4b328886f73a854d2","count":5},{"descriptor":"California Northern Remote Work","id":"a2aa2501ee34015666cf5f448422b30a","count":12},{"descriptor":"California Southern, US Offsite","id":"2e27a5a31dfb43d6b1fe21b8f268733c","count":6},{"descriptor":"California Southern Remote Work","id":"a2aa2501ee34016f686b59448422ae0a","count":13},{"descriptor":"Charlotte, NC","id":"09f65edec644100fb96d7a9a30a7de0e","count":1},{"descriptor":"Chicago, IL","id":"56b899ac82d3102ebb10086c343f0eed","count":45},{"descriptor":"Chile Remote Work","id":"a2aa2501ee340133264bcf4484220d0b","count":1},{"descriptor":"Colorado, US Offsite","id":"14ab7340d6e645c1827628a28827563a","count":1},{"descriptor":"Colorado Remote Work","id":"a2aa2501ee34015a1230464484229f0a","count":8},{"descriptor":"Connecticut, US Offsite","id":"399e74c7d2c4436ea401e45369f54a9c","count":3},{"descriptor":"Connecticut Remote Work","id":"a2aa2501ee3401d887c339448422950a","count":2},{"descriptor":"Cork, Ireland","id":"61b9ddf3a0c51000b136358fdbcb0000","count":1},{"descriptor":"Cork, Ireland - Business CNTR (ZEI16)","id":"e8aed7fb96be1000b4bd44c6150c0000","count":29},{"descriptor":"Culver City, CA","id":"f2cb61a1d06a01e3044baadd1f01ba77","count":7},{"descriptor":"Dallas, TX","id":"d0be8406d7eb0108618092b78c8c3d7d","count":4},{"descriptor":"Dallas, TX (TX143)","id":"61b9ddf3a0c51000b1184fb114ed0000","count":1},{"descriptor":"Delaware, US Offsite","id":"fdbba75aa4044c649cf4ddd888004e1e","count":8},{"descriptor":"Delaware Remote Work","id":"a2aa2501ee3401860b4433448422900a","count":5},{"descriptor":"Dubai, UAE","id":"7dda71e222860100aa71137f4c680000","count":2},{"descriptor":"Eagan, MN","id":"45632196659f01ded4d69952ac36dd7a","count":1},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Elgin, IL","id":"56b899ac82d3102ebe1e9ed8fc6722d7","count":1},{"descriptor":"Farmington Hills, MI (MI17)","id":"da1bb7b3041201d56bf55c9f774a95e3","count":1},{"descriptor":"Florida, US Offsite","id":"024e19ecdef743ea8576fd1f592a479c","count":23},{"descriptor":"Florida Remote Work","id":"a2aa2501ee34015d6ddb26478422fd0c","count":25},{"descriptor":"Fornebu, Norway (ZNO11)","id":"ba927ad987ee01020389e6b494000000","count":1},{"descriptor":"Fort Collins, CO (CO29)","id":"4114a9c5ddc501787dea77fde7019936","count":2},{"descriptor":"Fort Worth, TX (TX135)","id":"731a6d25b4bc01260a2ef4efbe0b4e60","count":2},{"descriptor":"Framingham, MA","id":"442a24924422100157ed1e5a4c5c0000","count":2},{"descriptor":"Fresno, CA (CA180)","id":"4114a9c5ddc501232fd3ac42e7010636","count":2},{"descriptor":"Ft. Lauderdale, FL (FL87)","id":"da5e91a4328101abe15bda8ec823a9bc","count":3},{"descriptor":"Georgia, US Offsite","id":"f1180d181cc140dba59dd0e993a002f1","count":15},{"descriptor":"Georgia Remote Work","id":"a2aa2501ee3401b67a9904478422df0c","count":15},{"descriptor":"Germany Offsite (ZWG99)","id":"5c1aee55369b44a2a5136da8dec8e315","count":6},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Glostrup, Denmark (ZDK02)","id":"27a1c404f5744ae68442996960fe2804","count":3},{"descriptor":"Greater Chicago Area","id":"a2aa2501ee34015128ebf2468422d00c","count":15},{"descriptor":"Greater Dallas Area","id":"a2aa2501ee34013ba7b67b4584229a0b","count":1},{"descriptor":"Gurgaon, India","id":"d879770ce5801001ba2441f0f8260000","count":4},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1},{"descriptor":"Ho Chi Minh, Vietnam","id":"04fbb808deef1000aba4980e9ce60000","count":2},{"descriptor":"Ho Chi Minh City, Vietnam (ZVI16)","id":"da5e91a4328101b8bd368cee2324adf1","count":1},{"descriptor":"Idaho, US Offsite","id":"de8af0de8a4f43e49ea4d4dc5a432216","count":1},{"descriptor":"Idaho Remote Work","id":"a2aa2501ee3401e0c730f9468422d50c","count":2},{"descriptor":"Idstein, Germany (ZWG86)","id":"04a42199937044bbbf6010ed72d1d007","count":2},{"descriptor":"Illinois, US Offsite","id":"037ebcbfd6ee4ad8a96ca2f9ec955366","count":36},{"descriptor":"Illinois Remote Work","id":"a2aa2501ee3401b4149aec468422cb0c","count":29},{"descriptor":"Indiana, US Offsite","id":"86ac456645c1476581ccafcdabd07091","count":11},{"descriptor":"Indianapolis, IN","id":"7f977422e7ba456a98281fb6d502202e","count":1},{"descriptor":"Indiana Remote Work","id":"a2aa2501ee3401181c56e6468422c60c","count":18},{"descriptor":"India Offsite (ZIN99)","id":"801ee26ff10b4e2389d3a9d125e02ae3","count":2},{"descriptor":"Iowa, US Offsite","id":"1787eed6fea6446f9bc1036e9a5962d9","count":2},{"descriptor":"Iowa Remote Work","id":"a2aa2501ee34012b9d0fda468422bc0c","count":7},{"descriptor":"Italy Offsite (ZIT99)","id":"7de50b13083047dfb5400de1b3b32aba","count":1},{"descriptor":"Kansas, US Offsite","id":"061f9780eeaf4ab392eb38562e8635c0","count":4},{"descriptor":"Kansas Remote Work","id":"a2aa2501ee3401a115bcd4468422b70c","count":5},{"descriptor":"Kentucky, US Offsite","id":"5e9d2bcbc1df436db79c28a492f83838","count":2},{"descriptor":"Kentucky Remote Work","id":"a2aa2501ee340110c46bcf468422b20c","count":2},{"descriptor":"Krakow, Poland","id":"cdb6c301cead01c0fd6255fbbe0073b9","count":89},{"descriptor":"Krakow, Poland","id":"30c4e7f824bd4b1a892b4ee4a537c2f7","count":2},{"descriptor":"Krakow, Poland","id":"3cc51f087f9747d5b0b2af9d001b0281","count":1},{"descriptor":"Kuala Lumpur, Malaysia","id":"817fef2f26ad4eec85f3d1f59f67a08c","count":2},{"descriptor":"Lexington, SC (SC07)","id":"da5e91a43281017cec012a9ab8239ba2","count":1},{"descriptor":"Linthicum, MD","id":"c152d08a5f9c104eed32617c8087529c","count":3},{"descriptor":"Lisbon, Portugal","id":"d0be8406d7eb01df5699f9468d8cf97d","count":9},{"descriptor":"Lisbon, Portugal","id":"60d771b675b201dd1b8cf4a90e01c534","count":1},{"descriptor":"Little Rock, AR","id":"9294dc0527c54192b5c8338f762402d1","count":1},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":3},{"descriptor":"Los Angeles, CA","id":"75eeec0cd30c4823b7cdbc46c87436e3","count":1},{"descriptor":"Los Angeles, CA","id":"20b991fa96e9475db727dbe3c7df1156","count":1},{"descriptor":"Louisiana Remote Work","id":"a2aa2501ee340134851ac4468422a80c","count":1},{"descriptor":"Machias, NY","id":"0a19dc5a4f9f4112af112d95245b34fc","count":1},{"descriptor":"Madrid, Spain","id":"8cfc0951b3b94bd98139c963eb68ec99","count":2},{"descriptor":"Maine, US Offsite","id":"992c04fd1a9c41d3a6a904ffe0de680c","count":3},{"descriptor":"Maine Remote Work","id":"a2aa2501ee34019d8ee2b74684229e0c","count":5},{"descriptor":"Manitoba Remote Work","id":"a2aa2501ee3401b8f6e9f44484222b0b","count":3},{"descriptor":"Maryland, US Offsite","id":"b83767d4324c46c999f575fd542abd88","count":16},{"descriptor":"Maryland Remote Work","id":"a2aa2501ee3401dbf94bb2468422990c","count":18},{"descriptor":"Massachusetts, US Offsite","id":"ef9ff0866473431aa0807077edea046d","count":18},{"descriptor":"Massachusetts Remote Work","id":"a2aa2501ee340136dff99f4684228a0c","count":13},{"descriptor":"Melbourne, Australia","id":"d7e3ba3b107b442382576d564fcbadfd","count":2},{"descriptor":"Mexico City, Mexico","id":"2b254088ddb54694997bd94b011e140c","count":4},{"descriptor":"Mexico Offsite","id":"5ef0f2a16491016a2dbdefc5034f5d9c","count":1},{"descriptor":"Michigan, US Offsite","id":"4b3514833681469ba0b512c446b25b97","count":11},{"descriptor":"Michigan Remote Work","id":"a2aa2501ee3401621d8898468422830c","count":13},{"descriptor":"Minnesota, US Offsite","id":"efb7395e01e54bde949ac224af8f56a6","count":3},{"descriptor":"Minnesota Remote Work","id":"a2aa2501ee34018daff981468422740c","count":9},{"descriptor":"Mississippi Remote Work","id":"a2aa2501ee340143de0a7c4684226f0c","count":2},{"descriptor":"Missouri, US Offsite","id":"fb75ff372ac14e1b809a1dd53333021e","count":2},{"descriptor":"Missouri Remote Work","id":"a2aa2501ee340123e99d6f468422650c","count":5},{"descriptor":"Montana, US Offsite","id":"add06bd26cdc4dcca751f6506e808c6a","count":1},{"descriptor":"Montana Remote Work","id":"a2aa2501ee3401c92dfa69468422600c","count":1},{"descriptor":"Morocco Offsite (ZMO99)","id":"13183554e71d4ea3b51cc01fb4310a38","count":1},{"descriptor":"Muscat, Oman","id":"7af2294c87014d38b73cc1f8e8046db2","count":1},{"descriptor":"Nebraska Remote Work","id":"a2aa2501ee3401c3ed27644684225b0c","count":1},{"descriptor":"Nevada, US Offsite","id":"63ba34e24ce44a5d92912e0cadae491c","count":1},{"descriptor":"Nevada Remote Work","id":"a2aa2501ee34015e595a5e468422560c","count":2},{"descriptor":"New Hampshire, US Offsite","id":"0727cec59d1544888ff072b50e96a1c3","count":5},{"descriptor":"New Hampshire Remote Work","id":"a2aa2501ee3401e10a2558468422510c","count":3},{"descriptor":"Newington, VA","id":"a2d68824ae0f4fdfa99ac487376a60c0","count":1},{"descriptor":"New Jersey, US Offsite","id":"dd456a04291641a5b02b5731f3e70d4a","count":10},{"descriptor":"New Jersey Remote Work","id":"a2aa2501ee340154abd2524684224c0c","count":14},{"descriptor":"New Mexico, US Offsite","id":"0bf30a8368014b0e90cd36a3c4d20e1a","count":2},{"descriptor":"New Mexico Remote Work","id":"a2aa2501ee3401cff79a46468422420c","count":4},{"descriptor":"New York, US Offsite","id":"3f76dd361d8b410784ca4fc8dc2421f7","count":8},{"descriptor":"New York Remote Work","id":"a2aa2501ee34015fb0b438468422380c","count":11},{"descriptor":"North Carolina, US Offsite","id":"2080bb98030b4515ba37427d91ff32cc","count":13},{"descriptor":"North Carolina Remote Work","id":"a2aa2501ee34015223b220468422210c","count":17},{"descriptor":"North Dakota, US Offsite","id":"a9996a2fd97f4d3e95a330c9526ec0b3","count":1},{"descriptor":"North Dakota Remote Work","id":"a2aa2501ee3401842df90e468422120c","count":3},{"descriptor":"NY52","id":"20a50c646bd31001a94e433910780000","count":1},{"descriptor":"Offsite France (ZFR99)","id":"71f31ba331b642f3a3ae05b211a469d1","count":1},{"descriptor":"Ohio, US Offsite","id":"c9f53b4342e94035b77570cfe5599af6","count":15},{"descriptor":"Ohio Remote Work","id":"a2aa2501ee34011ff5ccfc458422030c","count":14},{"descriptor":"Oklahoma, US Offsite","id":"7ceb761aa15d46d7b6c9a6bb4d05c509","count":4},{"descriptor":"Oklahoma Remote Work","id":"a2aa2501ee3401d33bbaf6458422fe0b","count":4},{"descriptor":"ONT39","id":"5c4e189f92a610016f2ffc6e5c630000","count":1},{"descriptor":"Ontario Remote Work","id":"a2aa2501ee340179e5f7e8448422210b","count":10},{"descriptor":"Oregon, US Offsite","id":"746c5cc1f07d48d7837f3db4895a18e7","count":10},{"descriptor":"Oregon Remote Work","id":"a2aa2501ee3401d4d45ff0458422f90b","count":6},{"descriptor":"Orlando, FL","id":"b7c95ddf5a041015a61c88e160676351","count":2},{"descriptor":"Oslo, Norway (ZNO07)","id":"8ef71253a56d4aaf92ff5a5364ccc8ac","count":1},{"descriptor":"Ottawa, Canada","id":"77e555f21e5501db407373e92a70fa79","count":1},{"descriptor":"Parma, OH","id":"9efafca5ae9041f7980582836384f807","count":1},{"descriptor":"Penang, Malaysia","id":"c6d7e2b64f8b107f215186f1d658a224","count":56},{"descriptor":"Penang, Malaysia","id":"8dfc527f8ed44cee87fe36c1afbaf264","count":1},{"descriptor":"Penang, Malaysia","id":"168b0d8a3214463583f95156388faf2d","count":1},{"descriptor":"Pennsylvania, US Offsite","id":"89941ac3741f436ab4e333e49a8fba84","count":16},{"descriptor":"Pennsylvania Remote Work","id":"a2aa2501ee3401fe0c4ed8458422e50b","count":12},{"descriptor":"Phoenix, AZ","id":"d0be8406d7eb01fa50265759958cbf87","count":1},{"descriptor":"Plantation, FL","id":"17ba885223814f9ab57dedd1e725b00a","count":7},{"descriptor":"Plantation, FL","id":"d879770ce5801001b9b947c3860f0000","count":1},{"descriptor":"Poland Offsite (ZPL99)","id":"9587715495c14b2b946ee753f5adba22","count":8},{"descriptor":"Portugal Offsite (ZPT99)","id":"22e48e01af704af5acf68a768e1184ed","count":1},{"descriptor":"Puerto Rico Offsite","id":"c35e2c7bf9b1444bb4c00699df114d76","count":1},{"descriptor":"Quebec Remote Work","id":"a2aa2501ee34017ab529dc448422170b","count":6},{"descriptor":"Reynosa, Mexico","id":"2cc4589d2ab01001021366bdbd430000","count":2},{"descriptor":"Rhode Island, US Offsite","id":"75ccaab07ff843b4bb5433ed70cbaff7","count":4},{"descriptor":"Rhode Island Remote Work","id":"a2aa2501ee34018f99a6c6458422d60b","count":1},{"descriptor":"Richardson, TX (TX141)","id":"a1b4b9c5b61b016ad44e1b6108028e25","count":1},{"descriptor":"Richmond, VA","id":"9ea53914b84d01586593035807010e1b","count":1},{"descriptor":"Riyadh, Saudi Arabia","id":"dfff2595c3404fe89fcea0c4a139065c","count":2},{"descriptor":"Romania Offsite (ZRO99)","id":"88268c4ae43b48c1bd5baa7007a31a71","count":1},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Sacramento, CA","id":"c4ee93d3538249b29c9fb0bfde3295be","count":1},{"descriptor":"San Mateo, CA","id":"3955e91ab9be1000d6a5f34dfd560000","count":1},{"descriptor":"Santiago, Chile","id":"ff21797042291056c1ed919d43474a6f","count":2},{"descriptor":"Santiago, Chile","id":"ff21797042291056c2a0d44e6f564d8b","count":1},{"descriptor":"Sao Paulo, Brazil","id":"d234454abe5110015dd3a0c5bb570000","count":5},{"descriptor":"Sarasota, FL","id":"279a8a3ddd4d018ef74c6ecba500157e","count":1},{"descriptor":"Saskatchewan Remote Work","id":"a2aa2501ee34019300f5d5448422120b","count":3},{"descriptor":"Schaumburg, IL","id":"5983637b827e4ed097966aa984c7cf6c","count":9},{"descriptor":"Schaumburg, IL","id":"f90bd5bcf3df4205a301db42c4557bdd","count":1},{"descriptor":"Schio, Italy","id":"a66ea95a586801014b0a39c8aa730000","count":1},{"descriptor":"Seoul, Korea","id":"8c4c7f5076070100bf635b3ff800ed4e","count":1},{"descriptor":"Singapore, Singapore","id":"914a4f61913c10357f56e7fd0de4f904","count":1},{"descriptor":"Singapore, Singapore (ZSG38)","id":"c6d7e2b64f8b107f233884cad328a5a5","count":1},{"descriptor":"Somerville, MA","id":"d0be8406d7eb01197d6786d18c8c617d","count":2},{"descriptor":"South Carolina, US Offsite","id":"4548f2167eca45daaa61d7c4aa7d08da","count":2},{"descriptor":"South Carolina Remote Work","id":"a2aa2501ee3401ac594eb9458422cc0b","count":10},{"descriptor":"South Dakota, US Offsite","id":"520ca850ee1443438ff88ea729c5dc1f","count":1},{"descriptor":"South Dakota Remote Work","id":"a2aa2501ee3401e9b731b3458422c70b","count":2},{"descriptor":"Spain Offsite (ZES99)","id":"301a357729b94516a34e3a61a35c1bb5","count":1},{"descriptor":"St. Petersburg, FL (FL92)","id":"4114a9c5ddc501b041023c10a301a7b6","count":1},{"descriptor":"Sterling, VA","id":"ca833823055501ee67c0d0e6ff01d6ee","count":1},{"descriptor":"St Petersburg, FL","id":"b9d0a434256f01442efa8db524cf8e23","count":1},{"descriptor":"Switzerland Offsite (ZSW99)","id":"bc6c8eecc49e4078ac65cd83165d02c5","count":1},{"descriptor":"Sydney, Australia (ZAS102)","id":"a161ce532f951001110b54a8d1f80000","count":1},{"descriptor":"Taguig, Philippines","id":"c6c7d41a752501ed42def116f4000e0e","count":1},{"descriptor":"Tennessee, US Offsite","id":"aa9f12002a984c16858ff0b2be54fce4","count":14},{"descriptor":"Tennessee Remote Work","id":"a2aa2501ee3401a15dcfac458422c20b","count":15},{"descriptor":"Texas, US Offsite","id":"7951f208c4a44af291de95d7063ca8ea","count":34},{"descriptor":"Texas Remote Work","id":"a2aa2501ee3401bb3ac08d458422a90b","count":26},{"descriptor":"Tokyo, Japan","id":"8c4c7f50760701262d4b1accf800fb4f","count":1},{"descriptor":"Toronto, Canada (ONT40)","id":"442a249244221001582c47e270eb0000","count":6},{"descriptor":"United Arab Emirates Offsite (ZUA99)","id":"dcc3bd6cdddc4454ad3336c2520953a5","count":1},{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":20},{"descriptor":"Utah, US Offsite","id":"f61b91f41da34642ae840d013eb6ec7d","count":19},{"descriptor":"Utah Remote Work","id":"a2aa2501ee3401463afc6e458422900b","count":11},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Vancouver, Canada","id":"d0be8406d7eb01e1ef6d1c418c8cf679","count":8},{"descriptor":"Vermont Remote Work","id":"a2aa2501ee3401d6729461458422840b","count":3},{"descriptor":"Versailles, France","id":"7dda71e222860100ab254c24897f0000","count":1},{"descriptor":"Vienna, Austria","id":"46a2113a7c421062bd06fb72dee26f45","count":1},{"descriptor":"Virginia, US Offsite","id":"c6987245ed6b4552b729aa8ca40c084f","count":16},{"descriptor":"Virginia Remote Work","id":"a2aa2501ee3401aefdf55a4584227f0b","count":11},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Warsaw, Poland","id":"d4e8b75046371067ca56ac231068e8e9","count":2},{"descriptor":"Warsaw, Poland","id":"c3422e7a11fd466e8a10d70edc3171ce","count":2},{"descriptor":"Washington, US Offsite","id":"0270f0ddaa9c4df780efe79b9477a4dc","count":5},{"descriptor":"Washington DC, US Offsite","id":"6703b0349e294f7982d1105b4180e6bf","count":4},{"descriptor":"Washington DC Remote Work","id":"a2aa2501ee34012ca4a4274484228b0a","count":6},{"descriptor":"Washington Remote Work","id":"a2aa2501ee3401c3bf02344584225d0b","count":10},{"descriptor":"Westminster, CO","id":"435c641825b8436a950f0c3c604cc62e","count":1},{"descriptor":"West Valley City, UT","id":"dc4b44bb9c9210367f2102c8f37b8c34","count":2},{"descriptor":"West Virginia, US Offsite","id":"41c94f5726b54db19a40ed8ab4c7016f","count":1},{"descriptor":"West Virginia Remote Work","id":"a2aa2501ee3401a5c1d62d458422580b","count":3},{"descriptor":"Wisconsin, US Offsite","id":"e350deb449e548d7be5c7185f399be05","count":3},{"descriptor":"Wisconsin Remote Work","id":"a2aa2501ee340159152027458422530b","count":14},{"descriptor":"Woodcliff Lake, NJ","id":"56b899ac82d3102ebddb9e5d99cf2205","count":2},{"descriptor":"Wyoming, US Offsite","id":"857b68215cb8413f8fc0085cc2df67b3","count":1},{"descriptor":"Wyoming Remote Work","id":"a2aa2501ee3401412f02214584224e0b","count":4},{"descriptor":"ZAS100","id":"20a50c646bd31001a8ec21fd6d5f0000","count":2}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:27 GMT
 - request:
     method: post
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/jobs
@@ -522,7 +229,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:13:59 GMT
+      - Tue, 30 Jul 2024 16:26:28 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -536,44 +243,44 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=b45edc4d5a99adc808511524f308114731985048-instance=vps-prod-986ku1e0.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=fc5f0486a9f5aff31be78571940661e59d148093-instance=vps-prod-kyncmfjs.prod-vps.pr501.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=Y6HqpLUh7eJzspXCSwlKn3TPO4kOAIocwJoQpW86Wa8-1722244439-1.0.1.1-E8wBiMzFArKsX4i6txXlA_gEFyrSe0hXtkP_0_fZw8N1Y2LOimGH97G68ThKWpl9Xn6PKfqm1hZoUjiBj5Nskw;
-        path=/; expires=Mon, 29-Jul-24 09:43:59 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=8lW1o1UL2eArD50XaRaugrJ_hOF677UC0xY_B3_.mHs-1722356788-1.0.1.1-pzFQs9BvPoxtKnHMn4.e9xpeKKP2auDVs2Hb_GmJNrrgOPmTeYJmZXwOsGIYFJ.hCee08AR1_Ql.xNdQ8gaJWw;
+        path=/; expires=Tue, 30-Jul-24 16:56:28 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxfFFDPoyZcZ9HN; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:13:59 GMT; HttpOnly
-      - _cfuvid=ozf0NmzRHPhkZpSRkJVsLz_6HF4b3fn2ky.gUVg35Lc-1722244439262-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKNFTtNTjdFAZDpBJbX6H2PBWqz2x; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:28 GMT; HttpOnly
+      - _cfuvid=CaUjHySsWqw.NwbVSBNo0moT2RE94DAGPBsZ7RJYAqk-1722356788663-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=1d331faf-0dd9-4ff4-9433-56745dbce68b; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=535469066.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=24178966-8a79-4658-b2dc-565284060226; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=1424661514.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|99a51f0d-0675-45e5-ab8c-b50c66561938
+      - VPS|1db61cd6-a5e1-48ba-88db-9322981a7198
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - DYNAMIC
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=9hqpYm39CkuCaZsHvMsonke7qGJ0cvgn5Q0H%2FCvuAXQXn2kusl4gI0ej4PAVSXl2L5O2JsUmUTl%2Bt1T%2BMe%2Fpy%2F%2FulI7P3ho7bRWHinl5GgjY20BV5G2o6UAmsKCyOp20pOawCeVY6nHcawtFwfzobFVvMSu43%2B9KYA%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=gUxIXtdlhlCv8YrPRH4fMwtK5QRV4rA0RM18%2FF93WNoAjYU19pEvacgT%2Byw%2BQ%2FhEvBe4Y6ccKxR7ZRxAIVu0yV1AwvhVfi8G487186h%2B%2Fk7wbrkox7ZynOgqgt%2BY0FlenqmFoOEobDwhctnrpOumMIWaAwIB%2BtF%2FmQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfefe38694263-EWR
+      - 8ab6b5e55aac80da-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"total":35,"jobPostings":[{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48791","Rugby, UK (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48793","Rugby, UK (ZUK107)"]},{"title":"Senior Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Software-Engineer_R48898-1","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 3 Days Ago","bulletFields":["R48898","Edinburgh, UK (ZUK129)"]},{"title":"Digital Campaigns Manager - EMEA","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Digital-Campaigns-Manager---EMEA_R45720","locationsText":"United Kingdom Offsite (ZUK99), More...","postedOn":"Posted 4 Days Ago","bulletFields":["R45720","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - North England & Midlands","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---Midlands_R48681","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 4 Days Ago","bulletFields":["R48681","United Kingdom Offsite (ZUK99)"]},{"title":"Technical Project Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Technical-Project-Manager_R47762","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 4 Days Ago","bulletFields":["R47762","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---South_R48682","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 5 Days Ago","bulletFields":["R48682","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Transmission Design Engineer / Authority","externalPath":"/job/Rugby-UK-ZUK107/Senior-Transmission-Design-Engineer---Authority_R48609","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 5 Days Ago","bulletFields":["R48609","Rugby, UK (ZUK107)"]},{"title":"Senior FP&A Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Senior-FP-A-Manager_R48163","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 6 Days Ago","bulletFields":["R48163","United Kingdom Offsite (ZUK99)"]},{"title":"Account Director – South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Account-Director---South_R48669","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 11 Days Ago","bulletFields":["R48669","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Frontend Developer","externalPath":"/job/Uxbridge-UK-ZUK131/Senior-Frontend-Developer_R48511","locationsText":"Uxbridge, UK (ZUK131), More...","postedOn":"Posted 13 Days Ago","bulletFields":["R48511","Uxbridge, UK (ZUK131)"]},{"title":"Regional Sales Director, CAM UK & Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Regional-Sales-Director--CAM-UK---Ireland_R48590","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 13 Days Ago","bulletFields":["R48590","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Sales Executive - South East","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---South-East_R48471","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 13 Days Ago","bulletFields":["R48471","United Kingdom Offsite (ZUK99)"]},{"title":"Senior System Engineer","externalPath":"/job/Rugby-UK-ZUK107/Senior-System-Engineer_R48513","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 14 Days Ago","bulletFields":["R48513","Rugby, UK (ZUK107)"]},{"title":"Channel Marketing Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Marketing-Manager_R47820-1","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 18 Days Ago","bulletFields":["R47820","United Kingdom Offsite (ZUK99)"]},{"title":"Software Configuration and Integrations Engineer","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Software-Configuration-and-Integrations-Engineer_R48514","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 18 Days Ago","bulletFields":["R48514","United Kingdom Offsite (ZUK99)"]},{"title":"Sr. Manager U.K. and Ireland Communications","externalPath":"/job/London-UK/Sr-Manager-UK-and-Ireland-Communications_R48263-1","locationsText":"London, UK","postedOn":"Posted 27 Days Ago","bulletFields":["R48263","London, UK (ZUK120)"]},{"title":"Junior Software Engineer","externalPath":"/job/Glasgow-UK-ZUK118/Junior-Software-Engineer_R47941","locationsText":"Glasgow, UK (ZUK118)","postedOn":"Posted 27 Days Ago","bulletFields":["R47941","Glasgow, UK (ZUK118)"]},{"title":"Senior Embedded Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Embedded-Software-Engineer_R47952","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 30+ Days Ago","bulletFields":["R47952","Edinburgh, UK (ZUK129)"]},{"title":"Channel Sales Executive - Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---Ireland_R48205","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48205","United Kingdom Offsite (ZUK99)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":16},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":6},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":4},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":3},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":3},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":2},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":1}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":35}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":35}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":227},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":96},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":64},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":60},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":35},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":24},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":19},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":9},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":8},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":5},{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":2},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":2},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"Taiwan","id":"a4e08b475d6a4176853c9d1cb9854e02","count":1},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":21},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":4},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
-  recorded_at: Mon, 29 Jul 2024 09:13:59 GMT
+        {"total":34,"jobPostings":[{"title":"Technical Support Specialist","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted Yesterday","bulletFields":["R48704","United Kingdom Offsite (ZUK99)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Yesterday","bulletFields":["R48791","Rugby, UK (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Yesterday","bulletFields":["R48793","Rugby, UK (ZUK107)"]},{"title":"Senior Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Software-Engineer_R48898-1","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 4 Days Ago","bulletFields":["R48898","Edinburgh, UK (ZUK129)"]},{"title":"Channel Account Manager - North England & Midlands","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---Midlands_R48681","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 5 Days Ago","bulletFields":["R48681","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---South_R48682","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 6 Days Ago","bulletFields":["R48682","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Transmission Design Engineer / Authority","externalPath":"/job/Rugby-UK-ZUK107/Senior-Transmission-Design-Engineer---Authority_R48609","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 6 Days Ago","bulletFields":["R48609","Rugby, UK (ZUK107)"]},{"title":"Senior FP&A Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Senior-FP-A-Manager_R48163","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 7 Days Ago","bulletFields":["R48163","United Kingdom Offsite (ZUK99)"]},{"title":"Account Director – South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Account-Director---South_R48669","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 12 Days Ago","bulletFields":["R48669","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Frontend Developer","externalPath":"/job/Uxbridge-UK-ZUK131/Senior-Frontend-Developer_R48511","locationsText":"Uxbridge, UK (ZUK131), More...","postedOn":"Posted 14 Days Ago","bulletFields":["R48511","Uxbridge, UK (ZUK131)"]},{"title":"Regional Sales Director, CAM UK & Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Regional-Sales-Director--CAM-UK---Ireland_R48590","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 14 Days Ago","bulletFields":["R48590","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Sales Executive - South East","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---South-East_R48471","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 14 Days Ago","bulletFields":["R48471","United Kingdom Offsite (ZUK99)"]},{"title":"Senior System Engineer","externalPath":"/job/Rugby-UK-ZUK107/Senior-System-Engineer_R48513","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 15 Days Ago","bulletFields":["R48513","Rugby, UK (ZUK107)"]},{"title":"Channel Marketing Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Marketing-Manager_R47820-1","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 19 Days Ago","bulletFields":["R47820","United Kingdom Offsite (ZUK99)"]},{"title":"Software Configuration and Integrations Engineer","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Software-Configuration-and-Integrations-Engineer_R48514","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 19 Days Ago","bulletFields":["R48514","United Kingdom Offsite (ZUK99)"]},{"title":"Sr. Manager U.K. and Ireland Communications","externalPath":"/job/London-UK/Sr-Manager-UK-and-Ireland-Communications_R48263-1","locationsText":"London, UK","postedOn":"Posted 28 Days Ago","bulletFields":["R48263","London, UK (ZUK120)"]},{"title":"Junior Software Engineer","externalPath":"/job/Glasgow-UK-ZUK118/Junior-Software-Engineer_R47941","locationsText":"Glasgow, UK (ZUK118)","postedOn":"Posted 28 Days Ago","bulletFields":["R47941","Glasgow, UK (ZUK118)"]},{"title":"Senior Embedded Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Embedded-Software-Engineer_R47952","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 30+ Days Ago","bulletFields":["R47952","Edinburgh, UK (ZUK129)"]},{"title":"Channel Sales Executive - Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---Ireland_R48205","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48205","United Kingdom Offsite (ZUK99)"]},{"title":"Finance Business Partner","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Finance-Business-Partner_R48124","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48124","United Kingdom Offsite (ZUK99)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":15},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":6},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":5},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":3},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":2},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":2},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":1}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":34}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":34}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":236},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":94},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":61},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":58},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":34},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":23},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":21},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":10},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":6},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":5},{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":1},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Korea, Republic of","id":"7a5a2aadf9d34086a2bfbfd408bc28da","count":1},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":20},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":3},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:28 GMT
 - request:
     method: get
-    uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791
+    uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704
     body:
       encoding: US-ASCII
       string: ''
@@ -590,7 +297,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:00 GMT
+      - Tue, 30 Jul 2024 16:26:29 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -604,41 +311,41 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=773d81738f7029154130bcc62e0b1712ea081169-instance=vps-prod-otqavz4t.prod-vps.pr502.cust.pdx.wd;
+      - PLAY_SESSION=f2e980771c24088c4052fa1aa3c5d3a4d6c92205-instance=vps-prod-vwebqnqw.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=aePaqFryRpZW1nwrve12U_x469td4OIGMaOMNAGm_Cc-1722244440-1.0.1.1-6Rzw_33GnOsMd4TdQCSUHmG9wxMjNIkiOKh.kmBY_J3124WEJYTh9B2zy6wt9kxKwfRfZK54WdNyJFpa4f_zJQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:00 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=1OMFqXoHPz5wgbLKcuaBEH0AUgHy3hyxmqlMQjb33h8-1722356789-1.0.1.1-LIYXENLQYtaijtzVCSG3CMph1mu7i7kkNZrrwcbCk8Ala3lfjgS23zPD2JwUmoaCly8gYc3va44eIA2KIOLTUg;
+        path=/; expires=Tue, 30-Jul-24 16:56:29 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxfFz2v1YDEpomn; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:00 GMT; HttpOnly
-      - _cfuvid=3n2zFR1CS_cPlL4EwdpwwT3pawoNtCB5aK.NACm_ch8-1722244440046-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxepqArWWibYiNg; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:29 GMT; HttpOnly
+      - _cfuvid=9ILY.1A.VnpzaQ.MJAdl84HG29OBNPc9jKR3Y_wIFuc-1722356789539-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=542f9c0e-bf8a-46ee-9e4e-4573b87d353c; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=3320617994.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=9dd5380c-7190-4b9b-8612-d693ab9a928a; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=3018628106.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|683ae0a2-2b12-4da8-b038-4c68fb02284f
+      - VPS|32328184-9f74-46cc-a480-2c3baca07c44
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - BYPASS
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=xGUZ5G7KdOItap0Vo83QXL8sN75DtFes4INratzgJ1aDE6N8TpZ5KYaV3kLZfEXOl44xTQP7i52FuztfbxEaRqqHGNaxU1KAUBdOQqvPc5%2FJH3L9zHobVGr9EIHD1Y2bYEXbYijU9SvfOKiDwJBSvNKnYcRPsZkrqA%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=jZHMm7%2BTFU%2FwcR035BV9UuJMALf6SDSMCAbsZWngR09VpsvYf6oaqVJ4En0Okhyvpmti7Kv1ZZNMcpLf0utrA%2BgHilF6kPWeRBC9ot9sKPSzHumdC1PnJangqxeGSQZNpv6eToTgdume3RjrzPqwLARRu14qO%2Bvv2g%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabff0419780fa7-EWR
+      - 8ab6b5eb988dc34f-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"jobPostingInfo":{"id":"0534f03727521000a37ba343a8f50000","title":"Customer Service & IT Advisor","jobDescription":"<h2><b>Company Overview</b></h2><p style=\"text-align:left\"><span>At Motorola Solutions, we&#39;re guided by a shared purpose - helping people be their best in the moments that matter - and we live up to our purpose every day by solving for safer. Because people can only be their best when they not only feel safe, but are safe. We&#39;re solving for safer by building the best possible technologies across every part of our safety and security ecosystem. That&#39;s mission-critical communications devices and networks, AI-powered video security &amp; access control and the ability to unite voice, video and data in a single command center view. We&#39;re solving for safer by connecting public safety agencies and enterprises, enabling the collaboration that&#39;s critical to connect those in need with those who can help. The work we do here matters.</span></p><h2><br /><b>Department Overview</b></h2>To deliver excellent Customer Service to Motorola Customers through effective and professional handing of Customer Incidents, Service Requests, Queries, Complaints and Internal IT issues received via telephone, email or Service Management Terminal.<br><br>This is the Motorola first point of contact and is in place to deliver first class service through effective resolution of incidents, and to proactively build an ongoing relationship with the customer. The role holder will understand and respond to the customer needs professionally.<h2><br>Job Description</h2><p><b>This role is also based onsite out of our Rugby office 5 days a week.</b></p><p></p><p><b>This role will require SC and NPPV3 security clearance which includes living in the UK for at least the past 5 years.</b></p><p></p><p>The role holder will develop and grow the skills required to support future products and services offered by Motorola including data products This is achieved through:</p><p></p><p>Development, improvement and adherence to, industry leading processes, procedures and best practices. Consistent delivery against agreed OLAs/KPIs and operational targets and Service Levels.</p><p></p><p>The delivery of a high quality and effective service management standard within the respective support procedures and activities.</p><p></p><p>The actions taken by this role and responsibility to the wider organisation will directly influence the customer &amp; desire to continue to employ the Motorola Services. The actions taken in this role and responsibility to the wider organisation will directly reflect in the Pulse of the Customer scores and the perception of Motorola&#39;s ability to manage customer contractual obligations and maintain excellent service.</p><p></p><p>The role holder will strive to achieve the customer service standards and targets that are agreed and documented in our customer contracts and meet high standards of operational excellence and delivery of quality. If this role did not exist then there would be no first line contact and diagnostic support for our customers.</p><p></p><p><b>Key Tasks:</b></p><p>• Customer Ingress and liaison by Phone, Email and Service Management Systems.</p><p>• Triage Incidents and Requests at a 1st line level, resolving at 1st line where possible.</p><p>• Use BMC Remedy to record, assign, monitor and update cases.</p><p>• Liaise with Suppliers for timely updates and co-ordinate responses.</p><p>• Progress and track orders through their life cycle to delivery.</p><p>• Monitor the jeopardy status and progress of cases.</p><p>• Escalate failure and risk to service level achievement.</p><p>• Ensure quality and accuracy of case data, identifying &amp; supporting Continual Service Improvement.</p><p></p><p>The role requires strength in organisation, collaboration, communication, negotiation, service delivery, influencing and the ability to deal with difficult customers.</p><p></p><p>Ability to develop and maintain strong working relationships within and outside the service desk environment.</p><p></p><p>Have demonstrable service desk experience and be able to evidence the ability to operate successfully in a demanding environment, whilst maintaining high morale, high achievement and actively supporting the collaborative culture that drives success.</p><p></p><p>Proactive approach to removing barriers and finding solutions to problems.</p><p>Flexible approach to operational demands and situations due to the changing nature of the role.</p><h2><br>Basic Requirements</h2><p><b>Basic Requirements</b></p><p>• Analytical skills and disciplined approach to resolving complex issues</p><p>• Able to improve processes and procedures</p><p>• Communication skills: Verbal, Written, Listening, and Questioning.</p><p>• Personal organisational skills</p><p>• The ability to influence and negotiate with internal and external parties</p><p>• Customer Focus</p><p>• Able to deal with change</p><p>• Ability to embrace new technologies</p><p>• Self motivated and enthusiastic</p><p>• Problem solving and fact-finding skills</p><p></p><p><b>Core competencies</b></p><p>• Proven ability in communication, both written and verbal</p><p>• Experience of working in a call centre or service centre environment</p><p>• Proficient in Computer systems and packages.</p><p>• Experience of working self-sufficiently and in a team environment delivering customer service</p><p>• ITIL V4 Foundation Qualification would be desirable.</p><p></p><p><b>In return for your expertise, we’ll support you in this new challenge with coaching and development every step of the way. Also, to reward your hard work you’ll get:</b></p><ul><li>Competitive salary and bonus schemes.</li><li>Two weeks additional pay per year (holiday bonus).</li><li>25 days holiday entitlement &#43; bank holidays. </li><li>Attractive defined contribution pension scheme.</li><li>Employee stock purchase plan.</li><li>Life assurance.</li><li>Enhanced maternity and paternity pay.</li><li>Career development support and wide ranging learning opportunities.</li><li>Employee health and wellbeing support EAP, wellbeing guidance etc.</li><li>Carbon neutral initiatives/goals.</li><li>Corporate social responsibility initiatives including support for volunteering days.</li><li>Well known companies discount scheme.</li></ul><p>#LI-KTB</p><h2><br>Travel Requirements</h2>Under 10%<h2><br>Relocation Provided</h2>None<h2><br>Position Type</h2>Experienced<p style=\"text-align:inherit\"></p><h2>Referral Payment Plan</h2>Yes<p style=\"text-align:inherit\"></p><h2><b>Company</b></h2>Airwave Solutions Limited<p></p><p><i><b>EEO Statement</b></i></p><p></p><p><span>Motorola Solutions is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion or belief, sex, sexual orientation, gender identity, national origin, disability, veteran status or any other legally-protected characteristic. </span></p><p></p><p><span>We are proud of our people-first and community-focused culture, empowering every Motorolan to be their most authentic self and to do their best work to deliver on the promise of a safer world. If you’d like to join our team but feel that you don’t quite meet all of the preferred skills, we’d still love to hear why you think you’d be a great addition to our team.</span></p><p></p><p><span>We’re committed to providing an inclusive and accessible recruiting experience for candidates with disabilities, or other physical or mental health conditions. To request an accommodation, please email </span><a href=\"mailto:ohr&#64;motorolasolutions.com\" target=\"_blank\"><span>ohr&#64;motorolasolutions.com</span></a>.</p>","location":"Rugby, UK (ZUK107)","postedOn":"Posted Today","startDate":"2024-07-29","timeType":"Full time","jobReqId":"R48791","jobPostingId":"Customer-Service---IT-Advisor_R48791","jobPostingSiteId":"Careers","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7"},"canApply":true,"posted":true,"includeResumeParsing":true,"jobRequisitionLocation":{"descriptor":"Rugby, UK (ZUK107)","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","alpha2Code":"GB"}},"externalUrl":"https://motorolasolutions.wd5.myworkdayjobs.com/Careers/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","questionnaireId":"a5be17decf0a100143593b79a2310000","secondaryQuestionnaireId":"088e7c9c80bf1001f0d143420d020000"},"hiringOrganization":{"name":"908250 Airwave Solutions Limited","url":""},"similarJobs":[],"userAuthenticated":false}
-  recorded_at: Mon, 29 Jul 2024 09:14:00 GMT
+        {"jobPostingInfo":{"id":"0534f03727521000b18e611ec37e0000","title":"Technical Support Specialist","jobDescription":"<h2><b>Company Overview</b></h2><p style=\"text-align:left\"><span>At Motorola Solutions, we&#39;re guided by a shared purpose - helping people be their best in the moments that matter - and we live up to our purpose every day by solving for safer. Because people can only be their best when they not only feel safe, but are safe. We&#39;re solving for safer by building the best possible technologies across every part of our safety and security ecosystem. That&#39;s mission-critical communications devices and networks, AI-powered video security &amp; access control and the ability to unite voice, video and data in a single command center view. We&#39;re solving for safer by connecting public safety agencies and enterprises, enabling the collaboration that&#39;s critical to connect those in need with those who can help. The work we do here matters.</span></p><h2><br /><b>Department Overview</b></h2>Motorola Solutions is a global leader in mission-critical communications and analytics. Our technology platforms in mission-critical communications, command center software and video security &amp; analytics, make cities safer as well as help communities and businesses thrive. At Motorola Solutions, we are ushering in a new era in public safety and security. Motorola Solution’s Video Division is defining the future of the security industry through innovative end-to-end-solutions and award-winning AI based surveillance systems. Artificial Intelligence is transforming the world and our team is advancing the field as it applies to the surveillance industry. We are proud to be industry leaders in video analytics with products like Appearance Search and Unusual Motion Detection along with our cloud service platform. Our video solutions have been installed in more than 120 countries at thousands of customer sites, including school campuses, transportation systems, healthcare centres, public venues, critical infrastructure, prisons, factories, casinos, airports, financial institutions, government facilities and retailers.<br><br>At Motorola Solutions, you will find a culture of thought-leaders who are passionate about creating exciting new solutions for security and surveillance. We seek problem-solvers who are eager to rise to the challenges of a continuously evolving technological industry, and those who want to make an impact on the safety of people and businesses globally.<h2><br>Job Description</h2><p><b>Overview:</b></p><p><span>Motorola Solutions Video Security &amp; Access Control division is hiring a Technical Support Engineer for its industry leading, disruptive Cloud Video platforms. Reporting to a Technical Support Team Lead, the Technical Support Engineer ensures critical customer issues are resolved quickly and accurately. Success in this role will be defined by: a strong customer-oriented mentality, a thorough systematic approach to troubleshooting, and the curiosity to learn about a diverse set of technologies. </span></p><p></p><p><b><b>Responsibilities:</b></b></p><ul><li><p><span>Learn and maintain a strong understanding of Motorola Solutions cloud software and products, including CCTV cameras, access control hardware, cloud software, mobile applications, servers and networks.</span></p></li><li><p><span>Troubleshoot Motorola Solutions hardware and software products over the phone, via live-chat, email and through remote sessions</span></p></li><li><p><span>Concisely document software, hardware, and network information in a case management system. </span></p></li><li><p><span>Provide an exceptional customer experience during calls, emails, chat, and customer escalations.</span></p></li><li><p><span>Prioritise between tasks, including inbound calls, live chat and email requests, as well as working on existing case management, and recreating behaviour.</span></p></li><li><p><span>Collaborate with the regional and global support teams to provide a high quality and effective customer experience</span></p></li><li><p><span>Be flexible to work on call for after hours and weekend support if required.</span></p></li><li><p><span>Continuously learn new skills, technologies &amp; products; keeping up with Motorola Solutions&#39; pace of innovation.</span></p></li><li><p><span>Resolve clients&#39; software or hardware issues by troubleshooting and diagnosing network and data problems, including utilising diagnostic tools, exporting debug logs, analysing log files, and reporting escalations to engineering.</span></p></li></ul><h2><br>Basic Requirements</h2><p><b>Requirements:</b></p><ul><li><p><span>Strong problem solving, organisational and analytical skills, with demonstrated ability to resolve customer issues in the shortest time at the highest quality.</span></p></li><li><p><span>Ability to read, write, and speak English fluently; w</span><span>ith well developed interpersonal communication (written and oral) skills and the ability to document and explain complex technical problems and solutions to customers of all skill levels, while being personable.</span></p></li><li><p><span>A self-starter who can work independently as well as collaborate effectively with team members with minimal supervision.  Agile, resourceful learner with strong attention to detail.</span></p></li><li><p><span>Ability to keep grace under pressure, multitask and prioritise based on business needs, provide timely updates, manage customer expectations and handle complex situations while troubleshooting critical issues &amp; maintaining effective communication with all stakeholders.</span></p></li><li><p><span>Demonstrates a continuous learning mindset to digest the technical details of an ever evolving product line.</span></p></li><li><p><span>Critical problem solving mindset with the ability to collect relevant data and reviewing basic logs to identify potential root causes.</span></p></li><li><p><span>Ability to replicate problems in a lab environment</span></p></li></ul><p></p><p><b>Candidates must be able to display a working knowledge with:</b></p><ul><li><p><span>Applying technical concepts to troubleshooting procedures</span></p></li><li><p><span>Installing, configuring, and troubleshooting various operating systems, software, and hardware.</span></p></li><li><p><span>Some knowledge of networking products and technologies (such as; TCP/IP, Ethernet, VoIP, Switches and Video Surveillance cameras/ Video Conferencing hardware).</span></p></li></ul><p></p><p><b>Preference will be given to candidates with the following skills and experience:</b></p><p></p><ul><li><p><span>Some relevant technical experience in any of the following business areas - Video Security, Analytics, Access Control, Telecommunication, Video Conferencing, Cloud software or Enterprise hardware support.</span></p></li><li><p><span>Degree/Diploma in Computer Engineering, Computer Information Systems, Computer Science or equivalent.</span></p></li><li><p><span>Certifications such as, but not limited to: CCNA, CCNP, MCSA, MTA, LFS, MCSE, CompTIA A&#43;.</span></p></li><li><p><span>A familiarity with the Onvif profile or other video streaming services.</span></p></li><li><p><span>Multi language proficiency.</span></p></li><li><p><span>Experience working in environments using the KCS Methodology.</span></p></li><li><p><span>Experience using CRM (Customer Relationship Management) systems.</span></p><p></p></li></ul><p><b>In return for your expertise, we’ll support you in this new challenge with coaching &amp; development every step of the way. Also, to reward your hard work you’ll get:</b></p><ul><li><p>Competitive salary and bonus schemes</p></li><li><p>Two weeks additional pay per year (holiday bonus)</p></li><li><p>25 days holiday entitlement &#43; bank holidays  </p></li><li><p>Attractive defined contribution pension scheme</p></li><li><p>Private medical insurance </p></li><li><p>Employee stock purchase plan</p></li><li><p>Flexible working options </p></li><li><p>Life assurance  </p></li><li><p>Enhanced maternity and paternity pay</p></li><li><p>Career development support and wide ranging learning opportunities</p></li><li><p>Employee health and wellbeing support EAP, wellbeing guidance etc</p></li><li><p>Carbon neutral initiatives/goals</p></li><li><p>Corporate social responsibility initiatives including support for volunteering days</p></li><li><p>Well known companies discount scheme</p></li></ul><p></p><p>#LI-AR1</p><h2><br>Travel Requirements</h2>10-25%<h2><br>Relocation Provided</h2>None<h2><br>Position Type</h2>Experienced<p style=\"text-align:inherit\"></p><h2>Referral Payment Plan</h2>Yes<p style=\"text-align:inherit\"></p><h2><b>Company</b></h2>Motorola Solutions UK Limited<p></p><p><i><b>EEO Statement</b></i></p><p></p><p><span>Motorola Solutions is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion or belief, sex, sexual orientation, gender identity, national origin, disability, veteran status or any other legally-protected characteristic. </span></p><p></p><p><span>We are proud of our people-first and community-focused culture, empowering every Motorolan to be their most authentic self and to do their best work to deliver on the promise of a safer world. If you’d like to join our team but feel that you don’t quite meet all of the preferred skills, we’d still love to hear why you think you’d be a great addition to our team.</span></p><p></p><p><span>We’re committed to providing an inclusive and accessible recruiting experience for candidates with disabilities, or other physical or mental health conditions. To request an accommodation, please email </span><a href=\"mailto:ohr&#64;motorolasolutions.com\" target=\"_blank\"><span>ohr&#64;motorolasolutions.com</span></a>.</p>","location":"United Kingdom Offsite (ZUK99)","postedOn":"Posted Yesterday","startDate":"2024-07-29","timeType":"Full time","jobReqId":"R48704","jobPostingId":"Technical-Support-Specialist_R48704","jobPostingSiteId":"Careers","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7"},"canApply":true,"posted":true,"includeResumeParsing":true,"jobRequisitionLocation":{"descriptor":"United Kingdom Offsite (ZUK99)","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","alpha2Code":"GB"}},"externalUrl":"https://motorolasolutions.wd5.myworkdayjobs.com/Careers/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704","questionnaireId":"a5be17decf0a100143593b79a2310000","secondaryQuestionnaireId":"088e7c9c80bf1001f0d143420d020000"},"hiringOrganization":{"name":"908000 Motorola Solutions UK Limited","url":""},"similarJobs":[],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:29 GMT
 - request:
     method: post
     uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
@@ -664,9 +371,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:14:00 GMT
+      - Tue, 30 Jul 2024 16:26:30 GMT
       Etag:
-      - W/"1722244440833"
+      - W/"1722356790136"
       Server:
       - openresty
       X-Cb-Engine:
@@ -678,11 +385,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '7'
+      - '6'
       X-Cb-Engine-Total-Count:
       - '4'
       X-Cb-Request-Took:
-      - '15'
+      - '18'
       Content-Length:
       - '603'
       Connection:
@@ -693,6 +400,6 @@ http_interactions:
         Solutions","identifier":{"permalink":"motorola-solutions","image_id":"v1470312559/vu37o8t5k4xdhtonwpxx.png","uuid":"d65bcbfb-b94e-e848-a953-bcd89ab7de00","entity_def_id":"organization","value":"Motorola
         Solutions"},"linkedin":{"value":"http://www.linkedin.com/company/motorolasolutions"},"short_description":"Motorola
         Solutions creates mission-critical communication solutions and services for
-        public safety and commercial customers.","rank_org":328,"website_url":"http://www.motorolasolutions.com"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:14:00 GMT
+        public safety and commercial customers.","rank_org":336,"website_url":"http://www.motorolasolutions.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:26:30 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_ashbyhq.yml b/spec/fixtures/cassettes/create_job_ashbyhq.yml
index c03da05f..4a7809d8 100644
--- a/spec/fixtures/cassettes/create_job_ashbyhq.yml
+++ b/spec/fixtures/cassettes/create_job_ashbyhq.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:30:17 GMT
+      - Tue, 30 Jul 2024 16:28:03 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -27,7 +27,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J3YX72PEMAGWFEEBB2SFCYJ4
+      - 01J427GQDCQDVRG64HDSBM0QGZ
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -43,14 +43,14 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac16e41a4a71c8-LHR
+      - 8ab6b8355bcb633d-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         {"jobs":[{"id":"309706bc-1081-48b6-89dc-f769bbe17e6d","title":"Analytics Engineering Advocate","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-07-15T16:45:14.721+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d","applyUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d/application","descriptionHtml":"<h2>About Lightdash</h2><p style=\"min-height:1.5em\">Lightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.</p><p style=\"min-height:1.5em\">We’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.</p><p style=\"min-height:1.5em\">We’re helping data teams build data-driven companies so they can make better decisions, faster.</p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><h2>About the role</h2><p style=\"min-height:1.5em\">At Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.</p><p style=\"min-height:1.5em\">Our users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.</p><p style=\"min-height:1.5em\"></p><h2><strong>Areas of Responsibility:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>Obsess over the success of our users:</strong> Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.</p></li><li><p style=\"min-height:1.5em\"><strong>Lightdash champion:</strong> You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash <em><strong>at</strong></em> Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.</p></li><li><p style=\"min-height:1.5em\"><strong>Teach and share:</strong> Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.</p></li><li><p style=\"min-height:1.5em\"><strong>Community strategy:</strong> Building and executing strategies to grow and engage the analyst community around Lightdash.</p></li></ul><h2><strong>Requirements:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Experience with business intelligence and analytics engineering</p></li><li><p style=\"min-height:1.5em\">Strong verbal and written communication skills</p></li><li><p style=\"min-height:1.5em\">Comfortable with dbt, SQL, git, data visualization, and the command line</p></li></ul><h2><strong>KPIs owned by the role (WIP):</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Community size and engagement</p></li><li><p style=\"min-height:1.5em\">Customer support response times and NPS</p></li><li><p style=\"min-height:1.5em\">Content published and hits</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"ABOUT LIGHTDASH\n\nLightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.\n\nWe’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.\n\nWe’re helping data teams build data-driven companies so they can make better decisions, faster.\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nABOUT THE ROLE\n\nAt Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.\n\nOur users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.\n\n\nAREAS OF RESPONSIBILITY:\n\n - Obsess over the success of our users: Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.\n\n - Lightdash champion: You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash at Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.\n\n - Teach and share: Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.\n\n - Community strategy: Building and executing strategies to grow and engage the analyst community around Lightdash.\n\n\nREQUIREMENTS:\n\n - Experience with business intelligence and analytics engineering\n\n - Strong verbal and written communication skills\n\n - Comfortable with dbt, SQL, git, data visualization, and the command line\n\n\nKPIS OWNED BY THE ROLE (WIP):\n\n - Community size and engagement\n\n - Customer support response times and NPS\n\n - Content published and hits\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £95K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £95K","compensationTiers":[{"id":"7cc7b9bb-3f87-4a9c-8e43-604566dbbb54","tierSummary":"£60K – £95K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"13d62bbc-1c15-4ff9-9480-feef72e9847a","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"id":"5c26b271-dd8b-4749-acd3-be1a3b94e870","summary":"£60K – £95K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}],"summaryComponents":[{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}},{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
-  recorded_at: Mon, 29 Jul 2024 09:30:17 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:03 GMT
 - request:
     method: get
     uri: https://api.ashbyhq.com/posting-api/job-board/lightdash?includeCompensation=true
@@ -70,7 +70,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:30:17 GMT
+      - Tue, 30 Jul 2024 16:28:03 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -78,7 +78,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J3YX72XBK84XB5DRRA6ZJW2R
+      - 01J427GQQQM88Y1CH5CBWBQN3S
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -94,14 +94,14 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac16e56d2994c3-LHR
+      - 8ab6b8376fe39449-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         {"jobs":[{"id":"309706bc-1081-48b6-89dc-f769bbe17e6d","title":"Analytics Engineering Advocate","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-07-15T16:45:14.721+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d","applyUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d/application","descriptionHtml":"<h2>About Lightdash</h2><p style=\"min-height:1.5em\">Lightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.</p><p style=\"min-height:1.5em\">We’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.</p><p style=\"min-height:1.5em\">We’re helping data teams build data-driven companies so they can make better decisions, faster.</p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><h2>About the role</h2><p style=\"min-height:1.5em\">At Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.</p><p style=\"min-height:1.5em\">Our users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.</p><p style=\"min-height:1.5em\"></p><h2><strong>Areas of Responsibility:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>Obsess over the success of our users:</strong> Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.</p></li><li><p style=\"min-height:1.5em\"><strong>Lightdash champion:</strong> You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash <em><strong>at</strong></em> Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.</p></li><li><p style=\"min-height:1.5em\"><strong>Teach and share:</strong> Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.</p></li><li><p style=\"min-height:1.5em\"><strong>Community strategy:</strong> Building and executing strategies to grow and engage the analyst community around Lightdash.</p></li></ul><h2><strong>Requirements:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Experience with business intelligence and analytics engineering</p></li><li><p style=\"min-height:1.5em\">Strong verbal and written communication skills</p></li><li><p style=\"min-height:1.5em\">Comfortable with dbt, SQL, git, data visualization, and the command line</p></li></ul><h2><strong>KPIs owned by the role (WIP):</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Community size and engagement</p></li><li><p style=\"min-height:1.5em\">Customer support response times and NPS</p></li><li><p style=\"min-height:1.5em\">Content published and hits</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"ABOUT LIGHTDASH\n\nLightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.\n\nWe’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.\n\nWe’re helping data teams build data-driven companies so they can make better decisions, faster.\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nABOUT THE ROLE\n\nAt Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.\n\nOur users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.\n\n\nAREAS OF RESPONSIBILITY:\n\n - Obsess over the success of our users: Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.\n\n - Lightdash champion: You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash at Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.\n\n - Teach and share: Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.\n\n - Community strategy: Building and executing strategies to grow and engage the analyst community around Lightdash.\n\n\nREQUIREMENTS:\n\n - Experience with business intelligence and analytics engineering\n\n - Strong verbal and written communication skills\n\n - Comfortable with dbt, SQL, git, data visualization, and the command line\n\n\nKPIS OWNED BY THE ROLE (WIP):\n\n - Community size and engagement\n\n - Customer support response times and NPS\n\n - Content published and hits\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £95K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £95K","compensationTiers":[{"id":"7cc7b9bb-3f87-4a9c-8e43-604566dbbb54","tierSummary":"£60K – £95K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"13d62bbc-1c15-4ff9-9480-feef72e9847a","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"id":"5c26b271-dd8b-4749-acd3-be1a3b94e870","summary":"£60K – £95K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}],"summaryComponents":[{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}},{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
-  recorded_at: Mon, 29 Jul 2024 09:30:17 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:03 GMT
 - request:
     method: post
     uri: https://jobs.ashbyhq.com/api/non-user-graphql?op=ApiOrganizationFromHostedJobsPageName
@@ -128,7 +128,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:30:18 GMT
+      - Tue, 30 Jul 2024 16:28:03 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -136,7 +136,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J3YX738S02SGPYDBG1DR8AXK
+      - 01J427GR0RBHVY6JBAE5QR2N8N
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -154,13 +154,13 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac16e6bab39460-LHR
+      - 8ab6b8395b4493ee-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: '{"data":{"organization":{"name":"Lightdash","publicWebsite":"https://www.lightdash.com/","customJobsPageUrl":null,"hostedJobsPageSlug":"Lightdash","allowJobPostIndexing":true,"appConfirmationTrackingPixelHtml":null,"recruitingPrivacyPolicyUrl":null,"activeFeatureFlags":["AnonymousCandidateExperience","JobPostingAlwaysReturnFormRenders","JobPostingApplicationDeadlines","SchedulingNewDirectBookingReschedule","SourcingFormAutoFill","UnsubscribeLinks","VirusScanFiles","VirusScanShowResults"],"timezone":"Europe/London","__typename":"Organization","theme":{"colors":{"version":"1","colorPrimary600":"#7262FF","colorPrimary900":"#7262FF"},"showJobFilters":false,"showTeams":false,"showAutofillApplicationsBox":true,"applicationSubmittedSuccessMessage":null,"__typename":"Theme","logoWordmarkImageUrl":"https://app.ashbyhq.com/api/images/org-theme-wordmark/118a5d75-b907-4616-ade7-b67eaa6b5c16/314e7c4e-d0d9-494f-b7cd-7d008d80f41e.png","logoSquareImageUrl":"https://app.ashbyhq.com/api/images/org-theme-logo/118a5d75-b907-4616-ade7-b67eaa6b5c16/0e2997f7-6255-4c9e-9ea4-0199b51c80ef.png","jobBoardTopDescriptionHtml":null,"jobBoardBottomDescriptionHtml":null}}}}'
-  recorded_at: Mon, 29 Jul 2024 09:30:18 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:03 GMT
 - request:
     method: post
     uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
@@ -186,9 +186,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:30:19 GMT
+      - Tue, 30 Jul 2024 16:28:04 GMT
       Etag:
-      - W/"1722245419002"
+      - W/"1722356884113"
       Server:
       - openresty
       X-Cb-Engine:
@@ -204,7 +204,7 @@ http_interactions:
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '11'
+      - '16'
       Content-Length:
       - '498'
       Connection:
@@ -212,8 +212,8 @@ http_interactions:
     body:
       encoding: UTF-8
       string: '{"count":1,"entities":[{"uuid":"301bce04-1610-4369-a9db-29de9623e65f","properties":{"name":"Lightdash","identifier":{"permalink":"hubble-e65f","image_id":"1c3c7ecd819e45879f8987babbbf2fea","uuid":"301bce04-1610-4369-a9db-29de9623e65f","entity_def_id":"organization","value":"Lightdash"},"linkedin":{"value":"https://www.linkedin.com/company/lightdash"},"short_description":"Lightdash
-        turns a dbt project into a full-stack BI platform.","rank_org":80603,"website_url":"https://www.lightdash.com"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:30:19 GMT
+        turns a dbt project into a full-stack BI platform.","rank_org":80511,"website_url":"https://www.lightdash.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:04 GMT
 - request:
     method: get
     uri: https://api.ashbyhq.com/posting-api/job-board/lightdash?includeCompensation=true
@@ -233,7 +233,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:30:19 GMT
+      - Tue, 30 Jul 2024 16:28:04 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -241,7 +241,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J3YX747RE9ZCFY601E8JENMK
+      - 01J427GRYYBZ7XBDX88NJ21ADK
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -257,14 +257,14 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac16ee0c8476f0-LHR
+      - 8ab6b83ee8d24179-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         {"jobs":[{"id":"309706bc-1081-48b6-89dc-f769bbe17e6d","title":"Analytics Engineering Advocate","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-07-15T16:45:14.721+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d","applyUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d/application","descriptionHtml":"<h2>About Lightdash</h2><p style=\"min-height:1.5em\">Lightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.</p><p style=\"min-height:1.5em\">We’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.</p><p style=\"min-height:1.5em\">We’re helping data teams build data-driven companies so they can make better decisions, faster.</p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><h2>About the role</h2><p style=\"min-height:1.5em\">At Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.</p><p style=\"min-height:1.5em\">Our users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.</p><p style=\"min-height:1.5em\"></p><h2><strong>Areas of Responsibility:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>Obsess over the success of our users:</strong> Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.</p></li><li><p style=\"min-height:1.5em\"><strong>Lightdash champion:</strong> You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash <em><strong>at</strong></em> Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.</p></li><li><p style=\"min-height:1.5em\"><strong>Teach and share:</strong> Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.</p></li><li><p style=\"min-height:1.5em\"><strong>Community strategy:</strong> Building and executing strategies to grow and engage the analyst community around Lightdash.</p></li></ul><h2><strong>Requirements:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Experience with business intelligence and analytics engineering</p></li><li><p style=\"min-height:1.5em\">Strong verbal and written communication skills</p></li><li><p style=\"min-height:1.5em\">Comfortable with dbt, SQL, git, data visualization, and the command line</p></li></ul><h2><strong>KPIs owned by the role (WIP):</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Community size and engagement</p></li><li><p style=\"min-height:1.5em\">Customer support response times and NPS</p></li><li><p style=\"min-height:1.5em\">Content published and hits</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"ABOUT LIGHTDASH\n\nLightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.\n\nWe’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.\n\nWe’re helping data teams build data-driven companies so they can make better decisions, faster.\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nABOUT THE ROLE\n\nAt Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.\n\nOur users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.\n\n\nAREAS OF RESPONSIBILITY:\n\n - Obsess over the success of our users: Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.\n\n - Lightdash champion: You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash at Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.\n\n - Teach and share: Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.\n\n - Community strategy: Building and executing strategies to grow and engage the analyst community around Lightdash.\n\n\nREQUIREMENTS:\n\n - Experience with business intelligence and analytics engineering\n\n - Strong verbal and written communication skills\n\n - Comfortable with dbt, SQL, git, data visualization, and the command line\n\n\nKPIS OWNED BY THE ROLE (WIP):\n\n - Community size and engagement\n\n - Customer support response times and NPS\n\n - Content published and hits\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £95K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £95K","compensationTiers":[{"id":"7cc7b9bb-3f87-4a9c-8e43-604566dbbb54","tierSummary":"£60K – £95K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"13d62bbc-1c15-4ff9-9480-feef72e9847a","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"id":"5c26b271-dd8b-4749-acd3-be1a3b94e870","summary":"£60K – £95K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}],"summaryComponents":[{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}},{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
-  recorded_at: Mon, 29 Jul 2024 09:30:19 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:04 GMT
 - request:
     method: post
     uri: https://jobs.ashbyhq.com/api/non-user-graphql
@@ -295,7 +295,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:30:19 GMT
+      - Tue, 30 Jul 2024 16:28:04 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -303,7 +303,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J3YX74EQBJDK1ZTQ7BX30SXW
+      - 01J427GS7QH7MTDMJSKFDFMEJE
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -321,14 +321,14 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac16ef4b6b657a-LHR
+      - 8ab6b8412afd653d-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:30:19 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:04 GMT
 - request:
     method: post
     uri: https://jobs.ashbyhq.com/api/non-user-graphql
@@ -359,7 +359,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:30:19 GMT
+      - Tue, 30 Jul 2024 16:28:05 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -367,7 +367,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J3YX74TQV4VRGW0EKK88YW9M
+      - 01J427GSSJMKY7QBA4HK4TE4HX
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -385,14 +385,14 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac16f1b88294cc-LHR
+      - 8ab6b843af674179-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:30:19 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:05 GMT
 - request:
     method: post
     uri: https://jobs.ashbyhq.com/api/non-user-graphql
@@ -423,7 +423,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:30:20 GMT
+      - Tue, 30 Jul 2024 16:28:05 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -431,7 +431,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J3YX752F222MYYAFZ4X3786Q
+      - 01J427GT0TC434JMAEV3C0TK5T
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -449,12 +449,12 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac16f32a694887-LHR
+      - 8ab6b846184276b3-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:30:20 GMT
+        eyJkYXRhIjp7ImpvYlBvc3RpbmciOnsiYXBwbGljYXRpb25Gb3JtIjp7ImlkIjoiYWQ0OWZlOTUtYWU2OS00ZWE5LWExNTctMGYxOGIxMjMxODdiIiwiZm9ybUNvbnRyb2xzIjpbeyJpZGVudGlmaWVyIjoiY2ZlNzVlMGItOTkzNy00MDA3LTg5Y2MtYmNjOTFmZTQ0NDJhIiwidGl0bGUiOiJTdWJtaXQiLCJfX3R5cGVuYW1lIjoiRm9ybUNvbnRyb2wifV0sImVycm9yTWVzc2FnZXMiOltdLCJzZWN0aW9ucyI6W3sidGl0bGUiOm51bGwsImRlc2NyaXB0aW9uSHRtbCI6bnVsbCwiZmllbGRFbnRyaWVzIjpbeyJpZCI6ImFkNDlmZTk1LWFlNjktNGVhOS1hMTU3LTBmMThiMTIzMTg3Yl9fc3lzdGVtZmllbGRfbmFtZSIsImZpZWxkIjp7ImlkIjoiZjAwMTM5NDctOTlhYS00ZTY2LTg4YWEtMGE1N2YyZDNmZGFkIiwicGF0aCI6Il9zeXN0ZW1maWVsZF9uYW1lIiwiaHVtYW5SZWFkYWJsZVBhdGgiOiJOYW1lIiwidGl0bGUiOiJOYW1lIiwiaXNOdWxsYWJsZSI6ZmFsc2UsImlzUHJpdmF0ZSI6ZmFsc2UsImlzRGVhY3RpdmF0ZWQiOmZhbHNlLCJpc01hbnkiOmZhbHNlLCJtZXRhZGF0YSI6e30sInR5cGUiOiJTdHJpbmciLCJfX2F1dG9TZXJpYWxpemF0aW9uSUQiOiJTdHJpbmdGaWVsZCJ9LCJmaWVsZFZhbHVlIjpudWxsLCJpc1JlcXVpcmVkIjp0cnVlLCJkZXNjcmlwdGlvbkh0bWwiOiI8cD5GaXJzdCBhbmQgbGFzdCBuYW1lIHBsZWFzZSE8L3A+IiwiaXNIaWRkZW4iOm51bGwsIl9fdHlwZW5hbWUiOiJGb3JtRmllbGRFbnRyeSJ9LHsiaWQiOiJhZDQ5ZmU5NS1hZTY5LTRlYTktYTE1Ny0wZjE4YjEyMzE4N2JfX3N5c3RlbWZpZWxkX2VtYWlsIiwiZmllbGQiOnsiaWQiOiIyMzE5MDUyZC04NDczLTRhMDMtYTBhYi03ZjRhMjc5NTI4NjMiLCJwYXRoIjoiX3N5c3RlbWZpZWxkX2VtYWlsIiwiaHVtYW5SZWFkYWJsZVBhdGgiOiJFbWFpbCIsInRpdGxlIjoiRW1haWwiLCJpc051bGxhYmxlIjpmYWxzZSwiaXNQcml2YXRlIjpmYWxzZSwiaXNEZWFjdGl2YXRlZCI6ZmFsc2UsImlzTWFueSI6ZmFsc2UsIm1ldGFkYXRhIjp7fSwidHlwZSI6IkVtYWlsIiwiX19hdXRvU2VyaWFsaXphdGlvbklEIjoiRW1haWxGaWVsZCJ9LCJmaWVsZFZhbHVlIjpudWxsLCJpc1JlcXVpcmVkIjp0cnVlLCJkZXNjcmlwdGlvbkh0bWwiOm51bGwsImlzSGlkZGVuIjpudWxsLCJfX3R5cGVuYW1lIjoiRm9ybUZpZWxkRW50cnkifSx7ImlkIjoiYWQ0OWZlOTUtYWU2OS00ZWE5LWExNTctMGYxOGIxMjMxODdiXzAwNDE1NzE0LTc1ZjMtNDliOS1iODU2LWFjNjc0ZmQ1Y2U4YiIsImZpZWxkIjp7ImlkIjoiNTI4ZjAwZGItYTI1Ni00ZDY2LWJjZjYtZDE2YTA0NzkzN2IxIiwicGF0aCI6IjAwNDE1NzE0LTc1ZjMtNDliOS1iODU2LWFjNjc0ZmQ1Y2U4YiIsImh1bWFuUmVhZGFibGVQYXRoIjoiIiwidGl0bGUiOiJXaGVyZSBhcmUgeW91IGJhc2VkIG9yIHdoZXJlIHdvdWxkIHlvdSBiZSBwbGFubmluZyBvbiB3b3JraW5nIGZyb20/IiwiaXNOdWxsYWJsZSI6ZmFsc2UsImlzUHJpdmF0ZSI6ZmFsc2UsImlzRGVhY3RpdmF0ZWQiOmZhbHNlLCJpc01hbnkiOmZhbHNlLCJtZXRhZGF0YSI6e30sInR5cGUiOiJMb2NhdGlvbiIsImxvY2F0aW9uVHlwZXMiOlsiQ2l0eSJdLCJfX2F1dG9TZXJpYWxpemF0aW9uSUQiOiJMb2NhdGlvbkZpZWxkIn0sImZpZWxkVmFsdWUiOm51bGwsImlzUmVxdWlyZWQiOnRydWUsImRlc2NyaXB0aW9uSHRtbCI6bnVsbCwiaXNIaWRkZW4iOm51bGwsIl9fdHlwZW5hbWUiOiJGb3JtRmllbGRFbnRyeSJ9LHsiaWQiOiJhZDQ5ZmU5NS1hZTY5LTRlYTktYTE1Ny0wZjE4YjEyMzE4N2JfMzY5MTNiMWYtYzM0Zi00NjkzLTkxOWMtNDAwMzA0YTJhMTFkIiwiZmllbGQiOnsiaWQiOiI2MjQ4ZjRlOC1jY2I1LTQ1YWEtOWVmNy1iMzhkZThkYTE2ZWIiLCJwYXRoIjoiMzY5MTNiMWYtYzM0Zi00NjkzLTkxOWMtNDAwMzA0YTJhMTFkIiwiaHVtYW5SZWFkYWJsZVBhdGgiOiIiLCJ0aXRsZSI6IkNhbiB3ZSBnZXQgYSBsaW5rIHRvIHlvdXIgTGlua2VkaW4gcHJvZmlsZT/CoCIsImlzTnVsbGFibGUiOmZhbHNlLCJpc1ByaXZhdGUiOmZhbHNlLCJpc0RlYWN0aXZhdGVkIjpmYWxzZSwiaXNNYW55IjpmYWxzZSwibWV0YWRhdGEiOnt9LCJ0eXBlIjoiU3RyaW5nIiwiX19hdXRvU2VyaWFsaXphdGlvbklEIjoiU3RyaW5nRmllbGQifSwiZmllbGRWYWx1ZSI6bnVsbCwiaXNSZXF1aXJlZCI6dHJ1ZSwiZGVzY3JpcHRpb25IdG1sIjpudWxsLCJpc0hpZGRlbiI6bnVsbCwiX190eXBlbmFtZSI6IkZvcm1GaWVsZEVudHJ5In0seyJpZCI6ImFkNDlmZTk1LWFlNjktNGVhOS1hMTU3LTBmMThiMTIzMTg3Yl9mOTNiZmY4Yy0yNDQyLTQyYjctYjA0MC0zODc2ZmExNjBhYmEiLCJmaWVsZCI6eyJpZCI6ImE3NjJkYjZmLWNiYTktNGFmMS1iOWVjLWQ5ZDUwYzFiNmQ3YiIsInBhdGgiOiJmOTNiZmY4Yy0yNDQyLTQyYjctYjA0MC0zODc2ZmExNjBhYmEiLCJodW1hblJlYWRhYmxlUGF0aCI6IiIsInRpdGxlIjoiQ2FuIHlvdSB0ZWxsIHVzIHdoYXQgYXR0cmFjdGVkIHlvdSB0byBhcHBseSB0byBMaWdodGRhc2g/IiwiaXNOdWxsYWJsZSI6ZmFsc2UsImlzUHJpdmF0ZSI6ZmFsc2UsImlzRGVhY3RpdmF0ZWQiOmZhbHNlLCJpc01hbnkiOmZhbHNlLCJtZXRhZGF0YSI6e30sInR5cGUiOiJMb25nVGV4dCIsIl9fYXV0b1NlcmlhbGl6YXRpb25JRCI6IkxvbmdUZXh0RmllbGQifSwiZmllbGRWYWx1ZSI6bnVsbCwiaXNSZXF1aXJlZCI6dHJ1ZSwiZGVzY3JpcHRpb25IdG1sIjoiPHA+V2UgZG9uJ3QgbmVlZCBhIHdob2xlIGNvdmVyIGxldHRlciwgYSBjb3VwbGUgb2Ygc2VudGVuY2VzIHdpbGwgZG8hPC9wPiIsImlzSGlkZGVuIjpudWxsLCJfX3R5cGVuYW1lIjoiRm9ybUZpZWxkRW50cnkifSx7ImlkIjoiYWQ0OWZlOTUtYWU2OS00ZWE5LWExNTctMGYxOGIxMjMxODdiX19zeXN0ZW1maWVsZF9yZXN1bWUiLCJmaWVsZCI6eyJpZCI6Ijg2MDFkZDllLWNjNTUtNGRhNS1hNThmLTg2Mzc4MzEwZjllMiIsInBhdGgiOiJfc3lzdGVtZmllbGRfcmVzdW1lIiwiaHVtYW5SZWFkYWJsZVBhdGgiOiJSZXN1bWUiLCJ0aXRsZSI6IkRvIHlvdSBoYXZlIGEgcmVzdW1lIG9yIENWIHlvdSBjYW4gc2hhcmU/wqAiLCJpc051bGxhYmxlIjpmYWxzZSwiaXNQcml2YXRlIjpmYWxzZSwiaXNEZWFjdGl2YXRlZCI6ZmFsc2UsImlzTWFueSI6ZmFsc2UsIm1ldGFkYXRhIjp7fSwidHlwZSI6IkZpbGUiLCJfX2F1dG9TZXJpYWxpemF0aW9uSUQiOiJGaWxlRmllbGQifSwiZmllbGRWYWx1ZSI6bnVsbCwiaXNSZXF1aXJlZCI6ZmFsc2UsImRlc2NyaXB0aW9uSHRtbCI6bnVsbCwiaXNIaWRkZW4iOm51bGwsIl9fdHlwZW5hbWUiOiJGb3JtRmllbGRFbnRyeSJ9LHsiaWQiOiJhZDQ5ZmU5NS1hZTY5LTRlYTktYTE1Ny0wZjE4YjEyMzE4N2JfN2I0Y2M0NTktNzcwMS00NGVhLWE0ZmItYzhkNDA5ODEwNDg3IiwiZmllbGQiOnsiaWQiOiI3ZTg2NjRlOC03YTIyLTQ4MGMtOWUzOS03MWM1NDg5Yzk0M2MiLCJwYXRoIjoiN2I0Y2M0NTktNzcwMS00NGVhLWE0ZmItYzhkNDA5ODEwNDg3IiwiaHVtYW5SZWFkYWJsZVBhdGgiOiIiLCJ0aXRsZSI6IldlcmUgeW91IHJlZmVycmVkIHRvIHRoaXMgcm9sZT/CoCIsImlzTnVsbGFibGUiOmZhbHNlLCJpc1ByaXZhdGUiOmZhbHNlLCJpc0RlYWN0aXZhdGVkIjpmYWxzZSwiaXNNYW55IjpmYWxzZSwibWV0YWRhdGEiOnt9LCJ0eXBlIjoiU3RyaW5nIiwiX19hdXRvU2VyaWFsaXphdGlvbklEIjoiU3RyaW5nRmllbGQifSwiZmllbGRWYWx1ZSI6bnVsbCwiaXNSZXF1aXJlZCI6ZmFsc2UsImRlc2NyaXB0aW9uSHRtbCI6IjxwPlBsZWFzZSBwcm92aWRlIHRoZSBmdWxsIG5hbWUgb2Ygd2hvIHJlZmVycmVkIHlvdTwvcD4iLCJpc0hpZGRlbiI6bnVsbCwiX190eXBlbmFtZSI6IkZvcm1GaWVsZEVudHJ5In1dLCJpc0hpZGRlbiI6bnVsbCwiX190eXBlbmFtZSI6IkZvcm1TZWN0aW9uUmVuZGVyIn1dLCJzb3VyY2VGb3JtRGVmaW5pdGlvbklkIjoiNGU5N2MxN2ItM2ExYS00Mzg1LWI0ZjMtZDUyMWU3MDdhN2E0IiwiX190eXBlbmFtZSI6IkZvcm1SZW5kZXIifSwic3VydmV5Rm9ybXMiOltdLCJhcHBsaWNhdGlvbkRlYWRsaW5lIjpudWxsLCJhcHBsaWNhdGlvbkxpbWl0Q2FsbG91dEh0bWwiOm51bGwsIl9fdHlwZW5hbWUiOiJKb2JQb3N0aW5nRGV0YWlscyJ9fX0=
+  recorded_at: Tue, 30 Jul 2024 16:28:05 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_bamboohr.yml b/spec/fixtures/cassettes/create_job_bamboohr.yml
index b4c78987..1c3d2675 100644
--- a/spec/fixtures/cassettes/create_job_bamboohr.yml
+++ b/spec/fixtures/cassettes/create_job_bamboohr.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:39 GMT
+      - Tue, 30 Jul 2024 16:51:50 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -27,8 +27,8 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - PHPSESSID=jv3LSvwdhkdTw9Jxv1vM8tky-GdtMWyZ; path=/; secure; HttpOnly; SameSite=None
-      - _cfuvid=s_KVG1vQ4DmXd0zx32NTaKzY3nhljWcCOIGZqMMGI5I-1722243999947-0.0.1.1-604800000;
+      - PHPSESSID=JzDHriNepzZa8hdozRPwusaac5UY3vE-; path=/; secure; HttpOnly; SameSite=None
+      - _cfuvid=PlGqkWEJlEZC7wPJsBWd_Bfg.DHPA0LB_9F3gdih6N4-1722358310156-0.0.1.1-604800000;
         path=/; domain=.bamboohr.com; HttpOnly; Secure; SameSite=None
       Expires:
       - Thu, 19 Nov 1981 08:52:00 GMT
@@ -93,7 +93,7 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabf446ab7e634d-LHR
+      - 8ab6db0d7966643d-LHR
     body:
       encoding: ASCII-8BIT
       string: '{"meta":{"totalCount":9},"result":[{"id":"45","jobOpeningName":"Lead
@@ -120,7 +120,7 @@ http_interactions:
         Rica","state":null,"province":null,"city":null},"isRemote":null,"locationType":"1"},{"id":"87","jobOpeningName":"Client
         Service Executive","departmentId":"19034","departmentLabel":"50-000 - Customer
         Success","employmentStatusLabel":"Full-Time","location":{"city":"Bogota","state":null},"atsLocation":{"country":null,"state":null,"province":null,"city":null},"isRemote":null,"locationType":"2"}]}'
-  recorded_at: Mon, 29 Jul 2024 09:06:39 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:50 GMT
 - request:
     method: get
     uri: https://premise.bamboohr.com/careers/company-info/
@@ -140,7 +140,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:40 GMT
+      - Tue, 30 Jul 2024 16:51:50 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -148,8 +148,8 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - PHPSESSID=KGEn0My5B96g03MzlDWmFAQvWhNEoOM8; path=/; secure; HttpOnly; SameSite=None
-      - _cfuvid=Yp9A0HnftEUayv2p8bqe.KDfJo7dNJGYW0x4zmU8hRk-1722244000344-0.0.1.1-604800000;
+      - PHPSESSID=pWM-ecIyCFZTYP31h8HK65VbsOk58Poq; path=/; secure; HttpOnly; SameSite=None
+      - _cfuvid=RpmO3dY7Vla27j2l9touBi2Iibe0_Zk1ZDR.MdZWhQo-1722358310333-0.0.1.1-604800000;
         path=/; domain=.bamboohr.com; HttpOnly; Secure; SameSite=None
       Expires:
       - Thu, 19 Nov 1981 08:52:00 GMT
@@ -214,11 +214,11 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabf447ecb69499-LHR
+      - 8ab6db0eaeb3770b-LHR
     body:
       encoding: ASCII-8BIT
-      string: '{"meta":[],"result":{"name":"Premise","id":"490341","logoUrl":"https:\/\/images4.bamboohr.com\/490341\/logos\/cropped.jpg?v=34","careerShareUrl":"https:\/\/premise.bamboohr.com\/careers","shareImageUrl":"https:\/\/premise.bamboohr.com\/jobs\/share_image\/34","inTrial":false,"appSessId":"86b4a6b6e6e2df3d9cb3a2f04d6d6454c0399901"}}'
-  recorded_at: Mon, 29 Jul 2024 09:06:40 GMT
+      string: '{"meta":[],"result":{"name":"Premise","id":"490341","logoUrl":"https:\/\/images4.bamboohr.com\/490341\/logos\/cropped.jpg?v=34","careerShareUrl":"https:\/\/premise.bamboohr.com\/careers","shareImageUrl":"https:\/\/premise.bamboohr.com\/jobs\/share_image\/34","inTrial":false,"appSessId":"9c1b7deb6526924eac198e73522b0be1368c6ffc"}}'
+  recorded_at: Tue, 30 Jul 2024 16:51:50 GMT
 - request:
     method: get
     uri: https://premise.bamboohr.com/careers/list
@@ -238,7 +238,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:40 GMT
+      - Tue, 30 Jul 2024 16:51:50 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -246,8 +246,8 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - PHPSESSID=W7iyuEDTlw7IBNoEmuqaFGkZ8-QAB8QO; path=/; secure; HttpOnly; SameSite=None
-      - _cfuvid=7syyS3wlz2E6kLdygs5.tEGZCXbEBROSH_xO44UkEu0-1722244000537-0.0.1.1-604800000;
+      - PHPSESSID=f9kY5Y4qNzssscjjQXW9nXKcAvA3YTFe; path=/; secure; HttpOnly; SameSite=None
+      - _cfuvid=xUE0ojQON.2HxYkuWKaEnN0zpmeYOvYrmQ2nN.LLI20-1722358310538-0.0.1.1-604800000;
         path=/; domain=.bamboohr.com; HttpOnly; Secure; SameSite=None
       Expires:
       - Thu, 19 Nov 1981 08:52:00 GMT
@@ -312,7 +312,7 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabf44a6edf53a2-LHR
+      - 8ab6db0fc85f63cf-LHR
     body:
       encoding: ASCII-8BIT
       string: '{"meta":{"totalCount":9},"result":[{"id":"45","jobOpeningName":"Lead
@@ -339,7 +339,7 @@ http_interactions:
         Rica","state":null,"province":null,"city":null},"isRemote":null,"locationType":"1"},{"id":"87","jobOpeningName":"Client
         Service Executive","departmentId":"19034","departmentLabel":"50-000 - Customer
         Success","employmentStatusLabel":"Full-Time","location":{"city":"Bogota","state":null},"atsLocation":{"country":null,"state":null,"province":null,"city":null},"isRemote":null,"locationType":"2"}]}'
-  recorded_at: Mon, 29 Jul 2024 09:06:40 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:50 GMT
 - request:
     method: get
     uri: https://premise.bamboohr.com/careers/45/detail
@@ -359,7 +359,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:40 GMT
+      - Tue, 30 Jul 2024 16:51:50 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -367,9 +367,8 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - PHPSESSID=KiRuMbkxrDiF219ne9v%2CYzi%2CpVZTD9HS; path=/; secure; HttpOnly;
-        SameSite=None
-      - _cfuvid=lFrHJhzYku.BU.ROBfomYPmto9tfJggMFCVKBFUWmzc-1722244000768-0.0.1.1-604800000;
+      - PHPSESSID=lv-Cad8u9zvCP4a-gz3HAwNhyZNVhWDL; path=/; secure; HttpOnly; SameSite=None
+      - _cfuvid=9UYhTk25SQrEx.FcutHREOJPXU4PGSSf1zmeTyUK81w-1722358310775-0.0.1.1-604800000;
         path=/; domain=.bamboohr.com; HttpOnly; Secure; SameSite=None
       Expires:
       - Thu, 19 Nov 1981 08:52:00 GMT
@@ -434,7 +433,7 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabf44b9f296317-LHR
+      - 8ab6db111d8193f3-LHR
     body:
       encoding: ASCII-8BIT
       string: '{"meta":{},"result":{"jobOpening":{"jobOpeningShareUrl":"https:\/\/premise.bamboohr.com\/careers\/45","jobOpeningName":"Lead
@@ -579,7 +578,7 @@ http_interactions:
         you have experience with experience with Gig economy platforms or two-sided
         marketplaces?","type":"short","value":"","isValueOther":false,"hasOther":"no","options":[]},{"id":"97","isRequired":false,"question":"Do
         you have experience working with CPGs and Retail Execution fields?","type":"short","value":"","isValueOther":false,"hasOther":"no","options":[]}],"genderId":[],"ethnicityId":[],"veteranStatusId":[],"disabilityId":[]}}}'
-  recorded_at: Mon, 29 Jul 2024 09:06:40 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:50 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Ciudad%20de%20M%C3%A9xico,%20CDMX%2006600%20Mexico?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -599,7 +598,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:40 GMT
+      - Tue, 30 Jul 2024 16:51:51 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -617,18 +616,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - f33fd25e1bde94b98c1bc2ae10b17813
+      - d14f524a4ea6bdadbe8af61fd04bfad0
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75ba04635428083b422a55a24c6a8|Ref A: 7D3B6A549340410A9F9C6554352730EA
-        Ref B: DB3EDGE2911 Ref C: 2024-07-29T09:06:40Z'
+      - 'Ref A: 67AF7923F821421583689FDD62A53EF2 Ref B: DB3EDGE2511 Ref C: 2024-07-30T16:51:51Z|Ref
+        SnR: 66a91a27b84e4eed89d5fe80793dbff0'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-xl6qp, mapsplatform-forwardgeocoder-service-69c675d4f5-2nk9q
+      - mapsplatform-frontend-5989d449fd-vr9m2, mapsplatform-forwardgeocoder-service-69c675d4f5-jh6h9
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '72'
+      - '74'
       X-Azure-Ref:
-      - 20240729T090640Z-154b59dbc6dlgzszqzx37u7ksn00000009cg000000016ema
+      - 20240730T165151Z-154b59dbc6dg5gt9rt4g8rzcmn00000007t000000000rwe5
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -636,8 +635,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:40 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:51:51 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Ciudad%20de%20M%C3%A9xico?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -657,7 +656,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:41 GMT
+      - Tue, 30 Jul 2024 16:51:52 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -675,18 +674,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - f9ae7732e1a2d807e6fe5ff2a1ae6993
+      - 1882b6b2366681b6f59f17fb2f63c322
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75ba1bd084a2bb3dd7f6bf5e3e366|Ref A: 5AD039627DD2409794E77A169F363C4A
-        Ref B: DB3EDGE3222 Ref C: 2024-07-29T09:06:41Z'
+      - 'Ref SnR: 66a91a28c38d425086db2834b786e8ca|Ref A: F55BD61487B54165B96681D944126B87
+        Ref B: DB3EDGE1906 Ref C: 2024-07-30T16:51:52Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-qjcb2, mapsplatform-forwardgeocoder-service-69c675d4f5-xfhvv
+      - mapsplatform-frontend-5989d449fd-7xwbn, mapsplatform-forwardgeocoder-service-69c675d4f5-xfhvv
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '69'
+      - '154'
       X-Azure-Ref:
-      - 20240729T090641Z-154b59dbc6dnvxkkgu90qg6kt800000004z0000000007vrt
+      - 20240730T165152Z-154b59dbc6d9w7951fxgptmsxn0000000asg0000000027yw
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -694,8 +693,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:41 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:51:52 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/CDMX?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -715,7 +714,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:41 GMT
+      - Tue, 30 Jul 2024 16:51:53 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -733,18 +732,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - c6f8c76fa9926e6201ed4906da37434d
+      - aa116f4afa5edc285fe94f7ee03170cb
       X-Msedge-Ref:
-      - 'Ref A: 748AE62FE73241C98F8130D4E23538D1 Ref B: DB3EDGE3007 Ref C: 2024-07-29T09:06:41Z|Ref
-        SnR: 66a75ba199c947d09197f4e2fee49a70'
+      - 'Ref A: A6B301F3F9264FFD8E34976F2117DE45 Ref B: DB3EDGE2119 Ref C: 2024-07-30T16:51:53Z|Ref
+        SnR: 66a91a2927f04335983575798b81c834'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-lgrkj, mapsplatform-forwardgeocoder-service-69c675d4f5-wvlkf
+      - mapsplatform-frontend-5989d449fd-57vjn, mapsplatform-forwardgeocoder-service-69c675d4f5-wq4qq
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
       - '68'
       X-Azure-Ref:
-      - 20240729T090641Z-154b59dbc6d9w7951fxgptmsxn00000008hg000000016xgf
+      - 20240730T165153Z-154b59dbc6d5bjzw8f9f4spwa800000009u000000001h5hp
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -752,8 +751,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:41 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:51:53 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/06600?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -773,7 +772,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:41 GMT
+      - Tue, 30 Jul 2024 16:51:53 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -791,18 +790,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 2e1e20f68d05f766dce2e775d04ba5d8
+      - ca29bcd234da23c91481d00e80781926
       X-Msedge-Ref:
-      - 'Ref A: 628F9AB6541D4029929D8CCBD8778A34 Ref B: DB3EDGE2821 Ref C: 2024-07-29T09:06:41Z|Ref
-        SnR: 66a75ba196de47baadadc31199909d70'
+      - 'Ref SnR: 66a91a29c7ea479da36a50669df01511|Ref A: 204812F34EB04AF3AA68EFAA53BC3D15
+        Ref B: DB3EDGE3008 Ref C: 2024-07-30T16:51:53Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-57vjn, mapsplatform-forwardgeocoder-service-69c675d4f5-9fk55
+      - mapsplatform-frontend-5989d449fd-8z5f6, mapsplatform-forwardgeocoder-service-69c675d4f5-7z7j7
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '50'
+      - '59'
       X-Azure-Ref:
-      - 20240729T090641Z-17cc7bff75862jxttfu5e04r3800000007b0000000009370
+      - 20240730T165153Z-17cc7bff758djdsfkbzs17szgw00000005u0000000003s5x
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -810,8 +809,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:41 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:51:53 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Mexico?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -831,7 +830,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:41 GMT
+      - Tue, 30 Jul 2024 16:51:53 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -849,18 +848,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - d043b5604a6173245d14e79377533354
+      - 92043aa6a3a959a30ed22f8433c853a8
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75ba157e841b595f441604f510f1f|Ref A: F10ED75AC40049EBB3A07D0276DDB87E
-        Ref B: DB3EDGE3006 Ref C: 2024-07-29T09:06:41Z'
+      - 'Ref A: 86CAD4E2B9D64D9D8979AC7BB2502D13 Ref B: DB3EDGE1905 Ref C: 2024-07-30T16:51:53Z|Ref
+        SnR: 66a91a292fa5430780fc887c6f62f151'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-zk7ph, mapsplatform-forwardgeocoder-service-69c675d4f5-wvlkf
+      - mapsplatform-frontend-5989d449fd-l6szp, mapsplatform-forwardgeocoder-service-69c675d4f5-jh6h9
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '68'
+      - '69'
       X-Azure-Ref:
-      - 20240729T090641Z-17cc7bff758vrp8vr5bbxfz28w00000005rg0000000013mz
+      - 20240730T165153Z-154b59dbc6dwlvkrbdum70qw7s00000007p000000000wy5s
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -868,6 +867,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:41 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:51:53 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_greenhouse.yml b/spec/fixtures/cassettes/create_job_greenhouse.yml
index 2833416f..c0882091 100644
--- a/spec/fixtures/cassettes/create_job_greenhouse.yml
+++ b/spec/fixtures/cassettes/create_job_greenhouse.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:47 GMT
+      - Tue, 30 Jul 2024 16:51:54 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -36,9 +36,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - 2b29d226c860facf2acfc698508414ed
+      - 64af9fc519f8e72b236dcb9ac173e82a
       X-Runtime:
-      - '0.011218'
+      - '0.006368'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -78,7 +78,7 @@ http_interactions:
         Fellow - Part-Time, Fall Contract"},{"absolute_url":"https://boards.greenhouse.io/codepath/jobs/4321186007","data_compliance":[{"type":"gdpr","requires_consent":false,"requires_processing_consent":false,"requires_retention_consent":false,"retention_period":null}],"internal_job_id":4212100007,"location":{"name":"Remote,
         United States"},"metadata":null,"id":4321186007,"updated_at":"2024-07-18T18:41:00-04:00","requisition_id":"48","title":"Technical
         Interview Prep Instructor, Fall 2024"}],"meta":{"total":15}}'
-  recorded_at: Thu, 25 Jul 2024 13:38:47 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:54 GMT
 - request:
     method: get
     uri: https://boards-api.greenhouse.io/v1/boards/codepath/
@@ -98,7 +98,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:47 GMT
+      - Tue, 30 Jul 2024 16:51:54 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -115,9 +115,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - f59c3845baedfac6c107e1125c6d8ac8
+      - a8cd547fb91372f72acb1375d4626014
       X-Runtime:
-      - '0.014934'
+      - '0.014602'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -138,7 +138,7 @@ http_interactions:
         you have any questions about the validity of an email you have received, we
         encourage you to contact\u0026nbsp;\u003ca href=\"mailto:recruiting@codepath.org\"
         target=\"_blank\"\u003erecruiting@codepath.org\u003c/a\u003e\u0026nbsp;directly.\u0026nbsp;\u0026nbsp;\u003c/em\u003e\u003c/p\u003e"}'
-  recorded_at: Thu, 25 Jul 2024 13:38:47 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:54 GMT
 - request:
     method: get
     uri: https://job-boards.greenhouse.io/codepath/
@@ -158,7 +158,7 @@ http_interactions:
       message: Found
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:47 GMT
+      - Tue, 30 Jul 2024 16:51:54 GMT
       Transfer-Encoding:
       - chunked
       Connection:
@@ -199,7 +199,7 @@ http_interactions:
     body:
       encoding: UTF-8
       string: ''
-  recorded_at: Thu, 25 Jul 2024 13:38:47 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:54 GMT
 - request:
     method: get
     uri: https://boards.greenhouse.io/codepath
@@ -219,7 +219,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:48 GMT
+      - Tue, 30 Jul 2024 16:51:55 GMT
       Content-Type:
       - text/html; charset=utf-8
       Transfer-Encoding:
@@ -233,9 +233,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - c6178b9f1f4023f0eb8933e46b175aa2
+      - b24993901c76a41cab3a22ffbe354f11
       X-Runtime:
-      - '0.018149'
+      - '0.008883'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -246,7 +246,7 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         <!DOCTYPE html>
<html lang="en">
<head prefix="og: http://ogp.me/ns#">
<script>var _rollbarConfig = {"accessToken":"a9e544e2eb674f56b12d47e1d2ed4cd1","captureUncaught":true,"payload":{"environment":"production"},"hostBlockList":["linkedin.com","recruitics.com"],"checkIgnore":function(isUncaught, args, payload) {
  try {
    var isPhantomJS = window.navigator.userAgent.match(/phantomjs/i);
    var isSplash= window.navigator.userAgent.match(/splash version/i);
    var firefox = window.navigator.userAgent.match(/(firefox)\/(\w+)/i); // JSON, must escape slash
    var chrome = window.navigator.userAgent.match(/(chrome)\/(\w+)/i); // JSON, must escape slash

    var browserExtensionOrAutomationFile = function(frame) {
      var regExPatterns = [/^chrome-extension/, /^safari-extension/, /^moz-extension/, /^pptr/];
      return regExPatterns.some(function(regEx) {
        return regEx.test(frame.filename);
      });
    }

    var isBrowserExtensionOrAutomation = payload.body.trace &&
                                         payload.body.trace.frames &&
                                         payload.body.trace.frames.some(browserExtensionOrAutomationFile);

    var isFirefoxLessThan50;
    if (firefox) {
      var majorVersion = Number(firefox[2]);
      isFirefoxLessThan50 = majorVersion < 50
    }

    var isChromeLessThan50;
    if (chrome) {
      var chromeVersion = Number(chrome[2]);
      isChromeLessThan50 = chromeVersion < 50;
    }

    return Boolean(isPhantomJS) ||
           Boolean(isSplash) ||
           Boolean(isFirefoxLessThan50) ||
           Boolean(isChromeLessThan50) ||
           Boolean(isBrowserExtensionOrAutomation);
  } catch (e) {
    return true;
  }
}
,"ignoredMessages":["BetterJsPop","vungle","Script error","awliwidget","ResizeObserver loop completed with undelivered notifications.","jQuery is missing","Attempting to configurable attribute of unconfigurable property.","WeakMap is not defined","Cannot change the configurable attribute of","Cannot call method \"get\" of undefined","\\$ is not defined","Can't find variable: \\$","uncaught exception: \\[object Object\\]","Unexpected token ';'","Failed S3 Direct Upload for field: resume","Failed to open/load the window. Dropbox.choose and Dropbox.save should only be called from within a user-triggered event handler such as a tap or click event.","googletag","solana|ethereum","originalPrompt"]};</script>
<script>!function(r){var e={};function o(n){if(e[n])return e[n].exports;var t=e[n]={i:n,l:!1,exports:{}};return r[n].call(t.exports,t,t.exports,o),t.l=!0,t.exports}o.m=r,o.c=e,o.d=function(r,e,n){o.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},o.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},o.t=function(r,e){if(1&e&&(r=o(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var t in r)o.d(n,t,function(e){return r[e]}.bind(null,t));return n},o.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return o.d(e,"a",e),e},o.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},o.p="",o(o.s=0)}([function(r,e,o){"use strict";var n=o(1),t=o(5);_rollbarConfig=_rollbarConfig||{},_rollbarConfig.rollbarJsUrl=_rollbarConfig.rollbarJsUrl||"https://cdn.rollbar.com/rollbarjs/refs/tags/v2.26.1/rollbar.min.js",_rollbarConfig.async=void 0===_rollbarConfig.async||_rollbarConfig.async;var a=n.setupShim(window,_rollbarConfig),l=t(_rollbarConfig);window.rollbar=n.Rollbar,a.loadFull(window,document,!_rollbarConfig.async,_rollbarConfig,l)},function(r,e,o){"use strict";var n=o(2),t=o(3);function a(r){return function(){try{return r.apply(this,arguments)}catch(r){try{console.error("[Rollbar]: Internal error",r)}catch(r){}}}}var l=0;function i(r,e){this.options=r,this._rollbarOldOnError=null;var o=l++;this.shimId=function(){return o},"undefined"!=typeof window&&window._rollbarShims&&(window._rollbarShims[o]={handler:e,messages:[]})}var s=o(4),d=function(r,e){return new i(r,e)},c=function(r){return new s(d,r)};function u(r){return a((function(){var e=this,o=Array.prototype.slice.call(arguments,0),n={shim:e,method:r,args:o,ts:new Date};window._rollbarShims[this.shimId()].messages.push(n)}))}i.prototype.loadFull=function(r,e,o,n,t){var l=!1,i=e.createElement("script"),s=e.getElementsByTagName("script")[0],d=s.parentNode;i.crossOrigin="",i.src=n.rollbarJsUrl,o||(i.async=!0),i.onload=i.onreadystatechange=a((function(){if(!(l||this.readyState&&"loaded"!==this.readyState&&"complete"!==this.readyState)){i.onload=i.onreadystatechange=null;try{d.removeChild(i)}catch(r){}l=!0,function(){var e;if(void 0===r._rollbarDidLoad){e=new Error("rollbar.js did not load");for(var o,n,a,l,i=0;o=r._rollbarShims[i++];)for(o=o.messages||[];n=o.shift();)for(a=n.args||[],i=0;i<a.length;++i)if("function"==typeof(l=a[i])){l(e);break}}"function"==typeof t&&t(e)}()}})),d.insertBefore(i,s)},i.prototype.wrap=function(r,e,o){try{var n;if(n="function"==typeof e?e:function(){return e||{}},"function"!=typeof r)return r;if(r._isWrap)return r;if(!r._rollbar_wrapped&&(r._rollbar_wrapped=function(){o&&"function"==typeof o&&o.apply(this,arguments);try{return r.apply(this,arguments)}catch(o){var e=o;throw e&&("string"==typeof e&&(e=new String(e)),e._rollbarContext=n()||{},e._rollbarContext._wrappedSource=r.toString(),window._rollbarWrappedError=e),e}},r._rollbar_wrapped._isWrap=!0,r.hasOwnProperty))for(var t in r)r.hasOwnProperty(t)&&(r._rollbar_wrapped[t]=r[t]);return r._rollbar_wrapped}catch(e){return r}};for(var p="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,captureEvent,captureDomContentLoaded,captureLoad".split(","),f=0;f<p.length;++f)i.prototype[p[f]]=u(p[f]);r.exports={setupShim:function(r,e){if(r){var o=e.globalAlias||"Rollbar";if("object"==typeof r[o])return r[o];r._rollbarShims={},r._rollbarWrappedError=null;var l=new c(e);return a((function(){e.captureUncaught&&(l._rollbarOldOnError=r.onerror,n.captureUncaughtExceptions(r,l,!0),e.wrapGlobalEventHandlers&&t(r,l,!0)),e.captureUnhandledRejections&&n.captureUnhandledRejections(r,l,!0);var a=e.autoInstrument;return!1!==e.enabled&&(void 0===a||!0===a||function(r){return!("object"!=typeof r||void 0!==r.page&&!r.page)}(a))&&r.addEventListener&&(r.addEventListener("load",l.captureLoad.bind(l)),r.addEventListener("DOMContentLoaded",l.captureDomContentLoaded.bind(l))),r[o]=l,l}))()}},Rollbar:c}},function(r,e,o){"use strict";function n(r,e,o,n){r._rollbarWrappedError&&(n[4]||(n[4]=r._rollbarWrappedError),n[5]||(n[5]=r._rollbarWrappedError._rollbarContext),r._rollbarWrappedError=null);var t=e.handleUncaughtException.apply(e,n);o&&o.apply(r,n),"anonymous"===t&&(e.anonymousErrorsPending+=1)}r.exports={captureUncaughtExceptions:function(r,e,o){if(r){var t;if("function"==typeof e._rollbarOldOnError)t=e._rollbarOldOnError;else if(r.onerror){for(t=r.onerror;t._rollbarOldOnError;)t=t._rollbarOldOnError;e._rollbarOldOnError=t}e.handleAnonymousErrors();var a=function(){var o=Array.prototype.slice.call(arguments,0);n(r,e,t,o)};o&&(a._rollbarOldOnError=t),r.onerror=a}},captureUnhandledRejections:function(r,e,o){if(r){"function"==typeof r._rollbarURH&&r._rollbarURH.belongsToShim&&r.removeEventListener("unhandledrejection",r._rollbarURH);var n=function(r){var o,n,t;try{o=r.reason}catch(r){o=void 0}try{n=r.promise}catch(r){n="[unhandledrejection] error getting `promise` from event"}try{t=r.detail,!o&&t&&(o=t.reason,n=t.promise)}catch(r){}o||(o="[unhandledrejection] error getting `reason` from event"),e&&e.handleUnhandledRejection&&e.handleUnhandledRejection(o,n)};n.belongsToShim=o,r._rollbarURH=n,r.addEventListener("unhandledrejection",n)}}}},function(r,e,o){"use strict";function n(r,e,o){if(e.hasOwnProperty&&e.hasOwnProperty("addEventListener")){for(var n=e.addEventListener;n._rollbarOldAdd&&n.belongsToShim;)n=n._rollbarOldAdd;var t=function(e,o,t){n.call(this,e,r.wrap(o),t)};t._rollbarOldAdd=n,t.belongsToShim=o,e.addEventListener=t;for(var a=e.removeEventListener;a._rollbarOldRemove&&a.belongsToShim;)a=a._rollbarOldRemove;var l=function(r,e,o){a.call(this,r,e&&e._rollbar_wrapped||e,o)};l._rollbarOldRemove=a,l.belongsToShim=o,e.removeEventListener=l}}r.exports=function(r,e,o){if(r){var t,a,l="EventTarget,Window,Node,ApplicationCache,AudioTrackList,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");for(t=0;t<l.length;++t)r[a=l[t]]&&r[a].prototype&&n(e,r[a].prototype,o)}}},function(r,e,o){"use strict";function n(r,e){this.impl=r(e,this),this.options=e,function(r){for(var e=function(r){return function(){var e=Array.prototype.slice.call(arguments,0);if(this.impl[r])return this.impl[r].apply(this.impl,e)}},o="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,_createItem,wrap,loadFull,shimId,captureEvent,captureDomContentLoaded,captureLoad".split(","),n=0;n<o.length;n++)r[o[n]]=e(o[n])}(n.prototype)}n.prototype._swapAndProcessMessages=function(r,e){var o,n,t;for(this.impl=r(this.options);o=e.shift();)n=o.method,t=o.args,this[n]&&"function"==typeof this[n]&&("captureDomContentLoaded"===n||"captureLoad"===n?this[n].apply(this,[t[0],o.ts]):this[n].apply(this,t));return this},r.exports=n},function(r,e,o){"use strict";r.exports=function(r){return function(e){if(!e&&!window._rollbarInitialized){for(var o,n,t=(r=r||{}).globalAlias||"Rollbar",a=window.rollbar,l=function(r){return new a(r)},i=0;o=window._rollbarShims[i++];)n||(n=o.handler),o.handler._swapAndProcessMessages(l,o.messages);window[t]=n,window._rollbarInitialized=!0}}}}]);</script>
  <title>Jobs at CodePath</title>
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  <meta id="viewport" name="viewport" content ="width=device-width, minimum-scale=1.0" />
  <meta id="rendered-by" content="jben" />
  <link rel="stylesheet" media="all" href="https://boards.cdn.greenhouse.io/assets/application-503576cead2d834a5d82da818670031f8db2f2c51eb2512be35e876ded3907a1.css" />
<link rel="stylesheet" media="all" href="https://boards.cdn.greenhouse.io/assets/responsive-95ad71d0f9cbcb13adb28ed74687b15c00a64bb1c4a6ab47ab9072493777804c.css" />
  
        <link rel="stylesheet" media="screen" href="https://s7-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/custom_css_files/400/224/200/original/simple_greenhouse_job_board_(1).css?1718298473" />



    <meta property="og:title" content="CodePath"></meta>
    <meta property="og:description" content="It has come to our attention that the content in CodePath job postings is being utilized by scammers in an attempt to steal personal information. CodePath will never ask for your social security number, banking, credit card, or other financial information as part of the application process. Additionally, CodePath only accepts job applications via https://boards.greenhouse.io/codepath and initial contact to applicants will always come from no-reply@us.greenhouse-mail.io. If you have any questions about the validity of an email you have received, we encourage you to contact recruiting@codepath.org directly.  "></meta>
    <meta property="og:url" content="https://boards.greenhouse.io/codepath"></meta>
    <meta property="og:type" content="article"></meta>
      <meta property="og:image" content="https://s7-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/logos/400/224/200/original/c281ed94-e7ac-460a-93aa-c5ef819d97de.png?1697156490"></meta>

</head>
<body>
  <div id="wrapper">
    <div id="main" class="accessible">
      
<div id="flash_wrapper">
</div>


<div id="logo"><img alt="CodePath Logo" src="https://s7-recruiting.cdn.greenhouse.io/external_greenhouse_job_boards/logos/400/224/200/resized/c281ed94-e7ac-460a-93aa-c5ef819d97de.png?1697156490" width="81" height="75" /></div>

  <h1>CodePath</h1>

  <div id="content">
    <p><em>It has come to our attention that the content in CodePath job postings is being utilized by scammers in an attempt to steal personal information. CodePath will never ask for your social security number, banking, credit card, or other financial information as part of the application process. Additionally, CodePath only accepts job applications via&nbsp;</em><a href="https://boards.greenhouse.io/codepath" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://boards.greenhouse.io/codepath&amp;source=gmail&amp;ust=1706222647322000&amp;usg=AOvVaw3cp7GW91VlHWlwm-Vt6Q6w">https://boards.greenhouse.io/codepath</a>&nbsp;<em>and initial contact to applicants will always come from&nbsp;</em><a href="mailto:no-reply@us.greenhouse-mail.io" target="_blank">no-reply@us.greenhouse-mail.io</a>.<em>&nbsp;If you have any questions about the validity of an email you have received, we encourage you to contact&nbsp;<a href="mailto:recruiting@codepath.org" target="_blank">recruiting@codepath.org</a>&nbsp;directly.&nbsp;&nbsp;</em></p>
  </div>

    <h2 id="board_title">Current Job Openings</h2>

  



<div id="filter-count"></div>

  

<section class="level-0">
  <h3 id="4012729007">Office of the CEO</h3>

  <div class="opening" department_id="4012729007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true">
  <a data-mapped="true" href="/codepath/jobs/4035993007">Chief Learning Officer</a>
  <br/>
  <span class="location">United States</span>
</div>
  

<section class="child level-1">
  <h4 id="4012734007">Business Operations</h4>

  
  

<section class="child level-2">
  <h5 id="4012737007">People</h5>

  <div class="opening" department_id="4012729007,4012734007,4012737007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012734007="true" data-department-4012737007="true">
  <a data-mapped="true" href="/codepath/jobs/4228695007">Head of People</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  
</section>
</section>

<section class="child level-1">
  <h4 id="4012741007">Delivery </h4>

  <div class="opening" department_id="4012729007,4012741007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true">
  <a data-mapped="true" href="/codepath/jobs/4231989007">Senior Director of Learning</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  

<section class="child level-2">
  <h5 id="4012747007">Immersives </h5>

  <div class="opening" department_id="4012729007,4012741007,4012747007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012747007="true">
  <a data-mapped="true" href="/codepath/jobs/4426096007">Associate Instructor - Part Time, Fall Contract</a>
  <br/>
  <span class="location">Arlington, Virginia</span>
</div><div class="opening" department_id="4012729007,4012741007,4012747007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012747007="true">
  <a data-mapped="true" href="/codepath/jobs/4426098007">Lead Instructor - Part Time, Fall Contract</a>
  <br/>
  <span class="location">Arlington, Virginia</span>
</div><div class="opening" department_id="4012729007,4012741007,4012747007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012747007="true">
  <a data-mapped="true" href="/codepath/jobs/4426092007">Tech Fellow - Part-Time, Fall Contract</a>
  <br/>
  <span class="location">Arlington, Virginia</span>
</div>
  
</section>

<section class="child level-2">
  <h5 id="4012742007">Programs</h5>

  <div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4040346007">Lead Cybersecurity Instructor, Fall 2024</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4059099007">Lead Web Development Instructor Adjunct Fall 2024, Miami</a>
  <br/>
  <span class="location">Miami, Florida</span>
</div><div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4038805007">Lead Web Development Instructor, Fall 2024</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012741007,4012742007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012741007="true" data-department-4012742007="true">
  <a data-mapped="true" href="/codepath/jobs/4321186007">Technical Interview Prep Instructor, Fall 2024</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  
</section>
</section>

<section class="child level-1">
  <h4 id="4012728007">Marketing</h4>

  <div class="opening" department_id="4012728007,4012729007" office_id="4011420007" data-office-4011420007="true" data-department-4012728007="true" data-department-4012729007="true">
  <a data-mapped="true" href="/codepath/jobs/4425579007">Social Media Manager</a>
  <br/>
  <span class="location">United States</span>
</div>
  
</section>

<section class="child level-1">
  <h4 id="4012730007">Platform</h4>

  <div class="opening" department_id="4012729007,4012730007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012730007="true">
  <a data-mapped="true" href="/codepath/jobs/4426707007">Data Engineer</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012730007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012730007="true">
  <a data-mapped="true" href="/codepath/jobs/4425572007">Lead Product Manager</a>
  <br/>
  <span class="location">Remote, United States</span>
</div><div class="opening" department_id="4012729007,4012730007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012730007="true">
  <a data-mapped="true" href="/codepath/jobs/4035988007">Staff Software Engineer</a>
  <br/>
  <span class="location">United States</span>
</div>
  
</section>

<section class="child level-1">
  <h4 id="4012731007">Revenue </h4>

  
  

<section class="child level-2">
  <h5 id="4012732007">Philanthropy </h5>

  <div class="opening" department_id="4012729007,4012731007,4012732007" office_id="4011420007" data-office-4011420007="true" data-department-4012729007="true" data-department-4012731007="true" data-department-4012732007="true">
  <a data-mapped="true" href="/codepath/jobs/4384343007">Director of Institutional Giving</a>
  <br/>
  <span class="location">Remote, United States</span>
</div>
  
</section>
</section>
</section>
  



    </div>
  </div>

      <div id="footer">
    <span>Powered by</span>&nbsp;<a target="_blank" href="http://www.greenhouse.io/">
      <img border="0" alt="Greenhouse Logo" id="gh_logo" src="https://boards.cdn.greenhouse.io/assets/greenhouse-in-app-logo-green-236d994ee39682bb46e214901c264de0df582c97e949e7c854c3531b79f00240.svg" width="100" height="30" />
</a>    <div class="privacy-policy">
      Read our <a href="http://www.greenhouse.io/privacy-policy">Privacy Policy</a>
    </div>
  </div>

      <script src="https://boards.cdn.greenhouse.io/assets/application-fca88733b7aeeaa9c5ec61d2a7c378decfa1d9a2fbf233814adcac2e31b78dab.js"></script>

  <script src="https://boards.cdn.greenhouse.io/assets/index_init-a6a131b5ca4d4c5f93159e6682892d3c22c184dc5c33ad13c69c5fad2dc18a4a.js"></script>  

  </body>
</html>

-  recorded_at: Thu, 25 Jul 2024 13:38:48 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:55 GMT
 - request:
     method: get
     uri: https://boards-api.greenhouse.io/v1/boards/codepath/jobs
@@ -266,7 +266,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:48 GMT
+      - Tue, 30 Jul 2024 16:51:55 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -283,9 +283,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - 8efbcabffa1f2eb135ae6b9a9299db80
+      - 910f80047d4444ed4db8b6175113cde8
       X-Runtime:
-      - '0.010861'
+      - '0.012159'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -325,7 +325,7 @@ http_interactions:
         Fellow - Part-Time, Fall Contract"},{"absolute_url":"https://boards.greenhouse.io/codepath/jobs/4321186007","data_compliance":[{"type":"gdpr","requires_consent":false,"requires_processing_consent":false,"requires_retention_consent":false,"retention_period":null}],"internal_job_id":4212100007,"location":{"name":"Remote,
         United States"},"metadata":null,"id":4321186007,"updated_at":"2024-07-18T18:41:00-04:00","requisition_id":"48","title":"Technical
         Interview Prep Instructor, Fall 2024"}],"meta":{"total":15}}'
-  recorded_at: Thu, 25 Jul 2024 13:38:48 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:55 GMT
 - request:
     method: get
     uri: https://boards-api.greenhouse.io/v1/boards/codepath/jobs/4426096007?compliance=true&demographic_questions=true&location_questions=true&pay_transparency=true&questions=true
@@ -345,7 +345,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:49 GMT
+      - Tue, 30 Jul 2024 16:51:55 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -362,9 +362,9 @@ http_interactions:
       Cache-Control:
       - max-age=0, private, must-revalidate
       X-Request-Id:
-      - db2f680ac3b4b5922cb1ed7118f2df41
+      - bb1be6ea3b4e00a20e0b3e94abd5dd8c
       X-Runtime:
-      - '0.107003'
+      - '0.010692'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Xss-Protection:
@@ -375,7 +375,7 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         {"absolute_url":"https://boards.greenhouse.io/codepath/jobs/4426096007","data_compliance":[{"type":"gdpr","requires_consent":false,"requires_processing_consent":false,"requires_retention_consent":false,"retention_period":null}],"internal_job_id":4265789007,"location":{"name":"Arlington, Virginia"},"metadata":null,"id":4426096007,"updated_at":"2024-07-08T20:45:00-04:00","requisition_id":"58","title":"Associate Instructor - Part Time, Fall Contract","pay_input_ranges":[{"min_cents":5000,"max_cents":7000,"currency_type":"USD","title":"Pay range","blurb":""}],"content":"\u0026lt;div class=\u0026quot;content-intro\u0026quot;\u0026gt;\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-family: helvetica, arial, sans-serif; font-size: 10pt;\u0026quot;\u0026gt;CodePath is a national non-profit that is reprogramming higher education to create the most diverse generation of software engineers, CTOs, and founders. We deliver industry-vetted courses and career support centered on the needs of Black, Latino/a, Indigenous, and low-income students. Our students train with senior engineers, intern at top companies, and rise together to become the tech leaders of tomorrow. As of 2023, we\u0026#39;ve served 10,000 students a year nationwide, and we plan to scale up to ~100,000 students a year by 2028.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-family: helvetica, arial, sans-serif; font-size: 10pt;\u0026quot;\u0026gt;Founded in 2017, CodePath has taught over 26,000 students and delivered courses across over 110 universities. We are supported by some of the largest and most well-respected organizations, including Amazon, Andreessen Horowitz, Blue Meridian Partners, Comcast, Google, JP Morgan Chase, Knight Foundation, Meta, New Profit, and Salesforce, among others. In 2024, CodePath was recognized as one of the Most Innovative Companies in Education by \u0026lt;em\u0026gt;Fast Company\u0026lt;/em\u0026gt;.\u0026lt;br\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;** We will never ask for bank information or for you to download any programs as part of our job application process and initial communications to applicants will be sent directly from our HR department.\u0026lt;/span\u0026gt;\u0026lt;/strong\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026amp;nbsp;\u0026lt;/p\u0026gt;\u0026lt;/div\u0026gt;\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 12pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;About the Partner Program\u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;The program is designed to give high school students exposure to and competency in computer science tools, concepts, and skills in order to set them up for success in pursuing CS courses at college and future technical career opportunities. The program will offer an introductory technical course along with hands-on training through the partner.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Time Commitment -\u0026lt;/strong\u0026gt;\u0026lt;strong\u0026gt; \u0026lt;/strong\u0026gt;Part-Time Instructors will need to be available during the following dates: \u0026lt;strong\u0026gt;September 2nd, 2024 - November 22nd, 2024\u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Pre-Program: \u0026lt;/strong\u0026gt;September 2nd - September 20th, 2024\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Instructor Onboarding \u0026amp;amp; Training: up to 50 hours total. This includes weekly virtual synchronous training sessions and asynchronous program preparation\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;During Program:\u0026lt;/strong\u0026gt; September 23rd - November 18th, 2024\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Students will observe the Indigenous Peoples’ Day and Veterans Day holidays\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;16 hours / week of in-class instruction (M - Th from 2 - 6pm)\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Up to 12 hours /week instructional planning, meetings, admin time, and feedback\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Post Program:\u0026lt;/strong\u0026gt; November 18th - November 22nd, 2024\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Up to 15 hours\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Close out and student feedback submissions\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Program retrospective\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Other Program Details:\u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Program Location:\u0026lt;/strong\u0026gt; Arlington, Virginia\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Students:\u0026lt;/strong\u0026gt; 8-30\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Curriculum core technologies:\u0026lt;/strong\u0026gt; Basics of Python, Java, and other basic BE/FE technologies\u0026lt;/span\u0026gt;\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;p\u0026gt;\u0026amp;nbsp;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 12pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;About The Role\u0026amp;nbsp;\u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Location:\u0026lt;/strong\u0026gt; Arlington, Virginia\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Duration:\u0026lt;/strong\u0026gt; Contractor, September 2nd - November 22nd, 2024\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Reports To:\u0026lt;/strong\u0026gt; Senior Manager of Employer Programs\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Compensation:\u0026lt;/strong\u0026gt; $50-$70 per hour\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Our Instructors are passionate educators and technologists who are deeply invested in providing opportunities for students identifying with underrepresented groups in tech. Instructors are responsible for the overall in-class experience of participants in the program.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;The lead instructor will be responsible for delivering a world class student experience for the duration of the program teaching CodePath’s introductory course. In this course, students learn Python, Java, and other computer science fundamentals that will set them up for future success in their academic and professional careers. This course is a beginner-friendly introductory course that requires no prior knowledge. The lead instructor will deliver lessons, facilitate collaborative structured academic time, and support students in designing and executing their own original projects. In addition they will support with data collection and communication across all stakeholders to maximize program success and learnings.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026amp;nbsp;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 12pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Responsibilities\u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Assist the Lead instructor by sharing the responsibility of teaching technical lessons and providing classroom support for up to 16 hours per week to teach students the fundamentals of computer science\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Up to 12 hours /week instructional planning, meetings, admin time, and feedback\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Help facilitate and answer student questions during technical lessons on the fundamentals of computer science topics\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Troubleshoot and debug a range of student issues during independent worktime thoughtfully and professionally\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Adapt and create instructional materials from the course curriculum provided, and provide meaningful feedback to our curriculum team as the course progresses\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Assists the lead instructor with classroom management and administrative tasks\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Develop strong relationships with program participants to support their growth and development throughout the program\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;p\u0026gt;\u0026amp;nbsp;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;strong\u0026gt;\u0026lt;span style=\u0026quot;font-size: 12pt;\u0026quot;\u0026gt;Requirements\u0026lt;/span\u0026gt;\u0026lt;/strong\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;2+ years of instructional experience with a demonstrated track record of educational excellence\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Classroom support experience working with students, troubleshooting issues, and helping debug.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Strong understanding of core technologies: Python, Java, and other computer science fundamental technologies.\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Nice to have: experience in web development technologies in the backend and frontend\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Computer science (or related field) degree, or comparable experience working in/learning software development\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Experience working through shifting priorities and learning, while maintaining organization and control\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Formal experience working as a web developer in core technologies a plus\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Experience developing technical curriculum (and interest in playing a role in the development process of the curriculum) a plus\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Tech nonprofit, startup experience a plus\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;p\u0026gt;\u0026amp;nbsp;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 12pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;Compensation\u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;This is a seasonal, part-time (up to 28 hour/week) position.\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;Candidates will be paid a competitive hourly rate for part time training and program instruction. Our hourly band is $50-70 an hour. Candidate hourly rate is dependent on experience and new staff rarely start at the top of the range.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;This position is not eligible for medical, dental, or vision benefits or paid time-off. \u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\u0026lt;div class=\u0026quot;content-pay-transparency\u0026quot;\u0026gt;\u0026lt;div class=\u0026quot;pay-input\u0026quot;\u0026gt;\u0026lt;div class=\u0026quot;title\u0026quot;\u0026gt;Pay range\u0026lt;/div\u0026gt;\u0026lt;div class=\u0026quot;pay-range\u0026quot;\u0026gt;\u0026lt;span\u0026gt;$50\u0026lt;/span\u0026gt;\u0026lt;span class=\u0026quot;divider\u0026quot;\u0026gt;\u0026amp;mdash;\u0026lt;/span\u0026gt;\u0026lt;span\u0026gt;$70 USD\u0026lt;/span\u0026gt;\u0026lt;/div\u0026gt;\u0026lt;/div\u0026gt;\u0026lt;/div\u0026gt;\u0026lt;div class=\u0026quot;content-conclusion\u0026quot;\u0026gt;\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026amp;nbsp;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;\u0026lt;span style=\u0026quot;font-size: 12pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Benefits\u0026lt;/span\u0026gt;\u0026lt;/strong\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;We offer a comprehensive benefits package for\u0026amp;nbsp;\u0026lt;span style=\u0026quot;text-decoration: underline;\u0026quot;\u0026gt;full-time employees\u0026amp;nbsp;\u0026lt;/span\u0026gt;that includes:\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Medical, dental, and vision premiums paid at 90% for FT positions and their dependents\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Flexible vacation and sick time policy with 12 company paid holidays plus a week long \u0026quot;winter break\u0026quot; office closure from Christmas to New Years. Employees take the time when they need it\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Flexible workplace and work schedule\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;CodePath provides a laptop, monitor, and ergonomic office setup\u0026amp;nbsp;\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Annual professional development stipend\u0026amp;nbsp;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Ability to voluntarily contribute pre and post-tax earnings to our 401k plan\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Employer Provided Short Term Disability and 10 weeks paid leave to support our employees in growing their family\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;A commitment to developing leaders from within the organization\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Frequent opportunities to connect with students, universities, and communities we serve\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;li style=\u0026quot;line-height: 1.5; font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\n\u0026lt;p\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;Opportunities to engage, collaborate and partner with top technology companies, venture capitalists, and engineering leaders\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026amp;nbsp;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\u0026lt;strong\u0026gt;\u0026lt;span style=\u0026quot;font-size: 12pt;\u0026quot;\u0026gt;About the Current Team\u0026lt;/span\u0026gt;\u0026lt;/strong\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;We are individuals from a multitude of backgrounds, experiences, and unlikely stories, all connected by a single dream: a world in which regardless of background, socioeconomic status, gender, or race all people have pathways to reach their full potential.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;With a staff and board that cares deeply about diversity and equity, we believe that diverse perspectives and backgrounds create a richer work environment and enhance our ability to pursue our mission.\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;div\u0026gt;\n\u0026lt;div\u0026gt;\n\u0026lt;div class=\u0026quot;sc-1fwbcuw-0 hpukun\u0026quot;\u0026gt;\n\u0026lt;div\u0026gt;\n\u0026lt;p style=\u0026quot;line-height: 1.4;\u0026quot;\u0026gt;\u0026lt;span style=\u0026quot;font-size: 10pt; font-family: helvetica, arial, sans-serif;\u0026quot;\u0026gt;\u0026lt;em\u0026gt;\u0026lt;strong\u0026gt;Note: Research suggests that women and BIPOC individuals may self-select out of opportunities if they don’t meet 100% of the job requirements. We encourage individuals who believe they have the skills necessary to thrive at CodePath to apply for this role.\u0026lt;/strong\u0026gt;\u0026lt;/em\u0026gt;\u0026lt;/span\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;/div\u0026gt;\n\u0026lt;/div\u0026gt;\n\u0026lt;/div\u0026gt;\n\u0026lt;/div\u0026gt;\u0026lt;/div\u0026gt;","departments":[{"id":4012747007,"name":"Immersives ","child_ids":[],"parent_id":4012741007}],"offices":[{"id":4011420007,"name":"CodePath ","location":"United States","child_ids":[],"parent_id":null}],"compliance":[{"type":"eeoc","questions":[],"description":"\u0026lt;p\u0026gt;PUBLIC BURDEN STATEMENT: According to the Paperwork Reduction Act of 1995 no persons are required to respond to a collection of information unless such collection displays a valid OMB control number. This survey should take about 5 minutes to complete.\u0026lt;/p\u0026gt;\n"},{"type":"eeoc","questions":[{"required":false,"label":"DisabilityStatus","fields":[{"name":"disability_status","type":"multi_value_single_select","values":[{"label":"I do not want to answer","value":"3"},{"label":"No, I do not have a disability and have not had one in the past","value":"2"},{"label":"Yes, I have a disability, or have had one in the past","value":"1"}]}]}],"description":"\u0026lt;h3\u0026gt;\u0026lt;strong\u0026gt;Voluntary Self-Identification of Disability\u0026lt;/strong\u0026gt;\u0026lt;/h3\u0026gt;\n\u0026lt;div style=\u0026quot;display:flex; justify-content:space-between;\u0026quot;\u0026gt;\n  \u0026lt;div\u0026gt;\n    \u0026lt;div\u0026gt;Form CC-305\u0026lt;/div\u0026gt;\n    \u0026lt;div\u0026gt;Page 1 of 1\u0026lt;/div\u0026gt;\n  \u0026lt;/div\u0026gt;\n  \u0026lt;div\u0026gt;\n    \u0026lt;div\u0026gt;OMB Control Number 1250-0005\u0026lt;/div\u0026gt;\n    \u0026lt;div\u0026gt;Expires 04/30/2026\u0026lt;/div\u0026gt;\n  \u0026lt;/div\u0026gt;\n\u0026lt;/div\u0026gt;\n\u0026lt;br\u0026gt;\n\u0026lt;strong\u0026gt;Why are you being asked to complete this form?\u0026lt;/strong\u0026gt;\n\u0026lt;p\u0026gt;We are a federal contractor or subcontractor. The law requires us to provide equal employment opportunity to qualified people with disabilities. We have a goal of having at least 7% of our workers as people with disabilities. The law says we must measure our progress towards this goal. To do this, we must ask applicants and employees if they have a disability or have ever had one. People can become disabled, so we need to ask this question at least every five years.\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;Completing this form is voluntary, and we hope that you will choose to do so. Your answer is confidential. No one who makes hiring decisions will see it. Your decision to complete the form and your answer will not harm you in any way. If you want to learn more about the law or this form, visit the U.S. Department of Labor’s Office of Federal Contract Compliance Programs (OFCCP) website at \u0026lt;a href=\u0026quot;https://www.dol.gov/ofccp\u0026quot; target=\u0026quot;_blank\u0026quot;\u0026gt;www.dol.gov/ofccp\u0026lt;/a\u0026gt;.\u0026lt;/p\u0026gt;\n\u0026lt;strong\u0026gt;How do you know if you have a disability?\u0026lt;/strong\u0026gt;\n\u0026lt;p\u0026gt;A disability is a condition that substantially limits one or more of your “major life activities.” If you have or have ever had such a condition, you are a person with a disability. \u0026lt;strong\u0026gt;Disabilities include, but are not limited to:\u0026lt;/strong\u0026gt;\u0026lt;/p\u0026gt;\n\u0026lt;ul\u0026gt;\n  \u0026lt;li\u0026gt;Alcohol or other substance use disorder (not currently using drugs illegally)\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Autoimmune disorder, for example, lupus, fibromyalgia, rheumatoid arthritis, HIV/AIDS\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Blind or low vision\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Cancer (past or present)\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Cardiovascular or heart disease\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Celiac disease\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Cerebral palsy\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Deaf or serious difficulty hearing\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Diabetes\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Disfigurement, for example, disfigurement caused by burns, wounds, accidents, or congenital disorders\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Epilepsy or other seizure disorder\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Gastrointestinal disorders, for example, Crohn\u0026#39;s Disease, irritable bowel syndrome\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Intellectual or developmental disability\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Mental health conditions, for example, depression, bipolar disorder, anxiety disorder, schizophrenia, PTSD\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Missing limbs or partially missing limbs\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Mobility impairment, benefiting from the use of a wheelchair, scooter, walker, leg brace(s) and/or other supports\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Nervous system condition, for example, migraine headaches, Parkinson’s disease, multiple sclerosis (MS)\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Neurodivergence, for example, attention-deficit/hyperactivity disorder (ADHD), autism spectrum disorder, dyslexia, dyspraxia, other learning disabilities\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Partial or complete paralysis (any cause)\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Pulmonary or respiratory conditions, for example, tuberculosis, asthma, emphysema\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Short stature (dwarfism)\u0026lt;/li\u0026gt;\n  \u0026lt;li\u0026gt;Traumatic brain injury\u0026lt;/li\u0026gt;\n\u0026lt;/ul\u0026gt;\n"},{"type":"eeoc","questions":[{"required":false,"label":"VeteranStatus","fields":[{"name":"veteran_status","type":"multi_value_single_select","values":[{"label":"I don't wish to answer","value":"3"},{"label":"I identify as one or more of the classifications of a protected veteran","value":"2"},{"label":"I am not a protected veteran","value":"1"}]}]}],"description":"\u0026lt;p\u0026gt;\n  If you believe you belong to any of the categories of protected veterans listed below, please indicate by making the appropriate selection.\n  As a government contractor subject to the Vietnam Era Veterans Readjustment Assistance Act (VEVRAA), we request this information in order to measure\n  the effectiveness of the outreach and positive recruitment efforts we undertake pursuant to VEVRAA. Classification of protected categories\n  is as follows:\n\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;A \u0026quot;disabled veteran\u0026quot; is one of the following: a veteran of the U.S. military, ground, naval or air service who is entitled to compensation (or who but for the receipt of military retired pay would be entitled to compensation) under laws administered by the Secretary of Veterans Affairs; or a person who was discharged or released from active duty because of a service-connected disability.\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;A \u0026quot;recently separated veteran\u0026quot; means any veteran during the three-year period beginning on the date of such veteran\u0026#39;s discharge or release from active duty in the U.S. military, ground, naval, or air service.\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;An \u0026quot;active duty wartime or campaign badge veteran\u0026quot; means a veteran who served on active duty in the U.S. military, ground, naval or air service during a war, or in a campaign or expedition for which a campaign badge has been authorized under the laws administered by the Department of Defense.\u0026lt;/p\u0026gt;\n\u0026lt;p\u0026gt;An \u0026quot;Armed forces service medal veteran\u0026quot; means a veteran who, while serving on active duty in the U.S. military, ground, naval or air service, participated in a United States military operation for which an Armed Forces service medal was awarded pursuant to Executive Order 12985.\u0026lt;/p\u0026gt;\n"},{"type":"eeoc","questions":[{"required":false,"label":"Race","fields":[{"name":"race","type":"multi_value_single_select","values":[{"label":"Decline To Self Identify","value":"8"},{"label":"Two or More Races","value":"7"},{"label":"Native Hawaiian or Other Pacific Islander","value":"6"},{"label":"White","value":"5"},{"label":"Hispanic or Latino","value":"4"},{"label":"Black or African American","value":"3"},{"label":"Asian","value":"2"},{"label":"American Indian or Alaskan Native","value":"1"}]}]},{"required":false,"label":"Gender","fields":[{"name":"gender","type":"multi_value_single_select","values":[{"label":"Decline To Self Identify","value":"3"},{"label":"Female","value":"2"},{"label":"Male","value":"1"}]}]}],"description":"\u0026lt;h3\u0026gt;\u0026lt;strong\u0026gt;Voluntary Self-Identification\u0026lt;/strong\u0026gt;\u0026lt;/h3\u0026gt;\u0026lt;br/\u0026gt;\u0026lt;p\u0026gt;For government reporting purposes, we ask candidates to respond to the below self-identification survey.\nCompletion of the form is entirely voluntary. Whatever your decision, it will not be considered in the hiring\nprocess or thereafter. Any information that you do provide will be recorded and maintained in a\nconfidential file.\u0026lt;/p\u0026gt;\n\n\u0026lt;p\u0026gt;As set forth in Codepath.org’s Equal Employment Opportunity policy,\nwe do not discriminate on the basis of any protected group status under any applicable law.\u0026lt;/p\u0026gt;\n"}],"demographic_questions":{"header":"U.S. Standard Demographic Questions","description":"We invite applicants to share their demographic background. If you choose to complete this survey, your responses may be used to identify areas of improvement in our hiring process.","questions":[{"id":4006277007,"label":"How would you describe your gender identity? (mark all that apply)","required":false,"type":"multi_value_multi_select","answer_options":[{"id":4037604007,"label":"Man","free_form":false,"decline_to_answer":false},{"id":4037605007,"label":"Non-binary","free_form":false,"decline_to_answer":false},{"id":4037606007,"label":"Woman","free_form":false,"decline_to_answer":false},{"id":4037607007,"label":"I prefer to self-describe","free_form":true,"decline_to_answer":false},{"id":4037608007,"label":"I don't wish to answer","free_form":false,"decline_to_answer":false}]},{"id":4006278007,"label":"How would you describe your racial/ethnic background? (mark all that apply)","required":false,"type":"multi_value_multi_select","answer_options":[{"id":4037609007,"label":"Black or of African descent","free_form":false,"decline_to_answer":false},{"id":4037610007,"label":"East Asian","free_form":false,"decline_to_answer":false},{"id":4037611007,"label":"Hispanic, Latinx or of Spanish Origin","free_form":false,"decline_to_answer":false},{"id":4037612007,"label":"Indigenous, American Indian or Alaska Native","free_form":false,"decline_to_answer":false},{"id":4037613007,"label":"Middle Eastern or North African","free_form":false,"decline_to_answer":false},{"id":4037614007,"label":"Native Hawaiian or Pacific Islander","free_form":false,"decline_to_answer":false},{"id":4037615007,"label":"South Asian","free_form":false,"decline_to_answer":false},{"id":4037616007,"label":"Southeast Asian","free_form":false,"decline_to_answer":false},{"id":4037617007,"label":"White or European","free_form":false,"decline_to_answer":false},{"id":4037618007,"label":"I prefer to self-describe","free_form":true,"decline_to_answer":false},{"id":4037619007,"label":"I don't wish to answer","free_form":false,"decline_to_answer":false}]},{"id":4006279007,"label":"How would you describe your sexual orientation? (mark all that apply)","required":false,"type":"multi_value_multi_select","answer_options":[{"id":4037620007,"label":"Asexual","free_form":false,"decline_to_answer":false},{"id":4037621007,"label":"Bisexual and/or pansexual","free_form":false,"decline_to_answer":false},{"id":4037622007,"label":"Gay","free_form":false,"decline_to_answer":false},{"id":4037623007,"label":"Heterosexual","free_form":false,"decline_to_answer":false},{"id":4037624007,"label":"Lesbian","free_form":false,"decline_to_answer":false},{"id":4037625007,"label":"Queer","free_form":false,"decline_to_answer":false},{"id":4037626007,"label":"I prefer to self-describe","free_form":true,"decline_to_answer":false},{"id":4037627007,"label":"I don't wish to answer","free_form":false,"decline_to_answer":false}]},{"id":4006280007,"label":"Do you identify as transgender? (select one)","required":false,"type":"multi_value_single_select","answer_options":[{"id":4037628007,"label":"Yes","free_form":false,"decline_to_answer":false},{"id":4037629007,"label":"No","free_form":false,"decline_to_answer":false},{"id":4037630007,"label":"I prefer to self-describe","free_form":true,"decline_to_answer":false},{"id":4037631007,"label":"I don't wish to answer","free_form":false,"decline_to_answer":false}]},{"id":4006281007,"label":"Do you have a disability or chronic condition (physical, visual, auditory, cognitive, mental, emotional, or other) that substantially limits one or more of your major life activities, including mobility, communication (seeing, hearing, speaking), and learning? (select one)","required":false,"type":"multi_value_single_select","answer_options":[{"id":4037632007,"label":"Yes","free_form":false,"decline_to_answer":false},{"id":4037633007,"label":"No","free_form":false,"decline_to_answer":false},{"id":4037634007,"label":"I prefer to self-describe","free_form":true,"decline_to_answer":false},{"id":4037635007,"label":"I don't wish to answer","free_form":false,"decline_to_answer":false}]},{"id":4006282007,"label":"Are you a veteran or active member of the United States Armed Forces? (select one)","required":false,"type":"multi_value_single_select","answer_options":[{"id":4037636007,"label":"Yes, I am a veteran or active member","free_form":false,"decline_to_answer":false},{"id":4037637007,"label":"No, I am not a veteran or active member","free_form":false,"decline_to_answer":false},{"id":4037638007,"label":"I prefer to self-describe","free_form":true,"decline_to_answer":false},{"id":4037639007,"label":"I don't wish to answer","free_form":false,"decline_to_answer":false}]}]},"questions":[{"description":null,"label":"First Name","required":true,"fields":[{"name":"first_name","type":"input_text","values":[]}]},{"description":null,"label":"Last Name","required":true,"fields":[{"name":"last_name","type":"input_text","values":[]}]},{"description":null,"label":"Email","required":true,"fields":[{"name":"email","type":"input_text","values":[]}]},{"description":null,"label":"Phone","required":false,"fields":[{"name":"phone","type":"input_text","values":[]}]},{"description":null,"label":"Resume/CV","required":false,"fields":[{"name":"resume","type":"input_file","values":[]},{"name":"resume_text","type":"textarea","values":[]}]},{"description":null,"label":"Cover Letter","required":false,"fields":[{"name":"cover_letter","type":"input_file","values":[]},{"name":"cover_letter_text","type":"textarea","values":[]}]},{"description":null,"label":"LinkedIn Profile","required":true,"fields":[{"name":"question_6752548007","type":"input_text","values":[]}]},{"description":null,"label":"Why are you interested in working at CodePath?","required":true,"fields":[{"name":"question_6752549007","type":"textarea","values":[]}]},{"description":null,"label":"Are you currently authorized to work in the United States?","required":true,"fields":[{"name":"question_6752550007","type":"multi_value_single_select","values":[{"label":"Yes","value":1},{"label":"No","value":0}]}]},{"description":null,"label":"Are you currently located in the Arlington/DC area or willing to relocate?","required":true,"fields":[{"name":"question_6752551007","type":"multi_value_single_select","values":[{"label":"Yes","value":1},{"label":"No","value":0}]}]},{"description":null,"label":"How did you hear about CodePath? ","required":true,"fields":[{"name":"question_6752552007","type":"multi_value_single_select","values":[{"label":"LinkedIn","value":10044899007},{"label":"EDsurge","value":10044900007},{"label":"Idealist","value":10044901007},{"label":"Event/Conferences - Industry","value":10044902007},{"label":"News/Media","value":10044903007},{"label":"Referred by CodePath employee","value":10044904007},{"label":"Friend or Family (Non-employee)","value":10044905007},{"label":"Other","value":10044906007}]}]}],"location_questions":[]}
-  recorded_at: Thu, 25 Jul 2024 13:38:49 GMT
+  recorded_at: Tue, 30 Jul 2024 16:51:55 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Arlington,%20Virginia?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -395,7 +395,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:49 GMT
+      - Tue, 30 Jul 2024 16:51:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -413,18 +413,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 3c71fe2523a6a9e606de61a38397db7e
+      - 7f84a57b442aa24ed66b9a2e274b6b62
       X-Msedge-Ref:
-      - 'Ref SnR: 66a25569526c49d7961b2ec4c5fc6b65|Ref A: 0CA2EB829A23495DBC5A401D0D5F69A7
-        Ref B: DB3EDGE2612 Ref C: 2024-07-25T13:38:49Z'
+      - 'Ref A: E5C7BF973C2645088FFF5FE2AB917152 Ref B: DB3EDGE1711 Ref C: 2024-07-30T16:51:55Z|Ref
+        SnR: 66a91a2b86e64f27ab1fa56379edb2dc'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-dd2gk, mapsplatform-forwardgeocoder-service-5854b89bbc-frx5b
+      - mapsplatform-frontend-5989d449fd-pmchc, mapsplatform-forwardgeocoder-service-69c675d4f5-wvlkf
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '91'
+      - '75'
       X-Azure-Ref:
-      - 20240725T133849Z-r16f76c6d84wfvjceqhw0r1bhs000000031000000000qr0f
+      - 20240730T165155Z-17cc7bff758zbmb41069tapu8g000000083g00000000aua4
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -432,8 +432,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Thu, 25 Jul 2024 13:38:49 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:51:56 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Arlington?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -453,7 +453,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:49 GMT
+      - Tue, 30 Jul 2024 16:51:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -471,18 +471,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 2612d4ef1b1cf35439745be18738ef6a
+      - c51a7742a925aafcdc63368fddf6d706
       X-Msedge-Ref:
-      - 'Ref A: ADD6BB6DD3814FE097610B7DC66260C3 Ref B: DB3EDGE2513 Ref C: 2024-07-25T13:38:49Z|Ref
-        SnR: 66a25569521142daa60adaec489cf241'
+      - 'Ref SnR: 66a91a2c9d9a4617a5da0e281a7edc93|Ref A: 800DD445FBB74D508376D90A7352E155
+        Ref B: DB3EDGE1813 Ref C: 2024-07-30T16:51:56Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-xl6qp, mapsplatform-forwardgeocoder-service-5854b89bbc-pzmwp
+      - mapsplatform-frontend-5989d449fd-pjzdx, mapsplatform-forwardgeocoder-service-69c675d4f5-jh6h9
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '70'
+      - '74'
       X-Azure-Ref:
-      - 20240725T133849Z-r199894c6f4gdn2d5fx6qf31q800000003mg00000000kdm2
+      - 20240730T165156Z-154b59dbc6dh82c7m9kabap6k800000007u000000000uc42
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -490,8 +490,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Thu, 25 Jul 2024 13:38:49 GMT
+        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6NSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzMyLjU4NjU1OTI5NTY1NDMsLTk3LjIzMzczNDEzMDg1OTM4LDMyLjgxNzEzNDg1NzE3NzczNCwtOTcuMDM3MTg1NjY4OTQ1MzFdLCJuYW1lIjoiQXJsaW5ndG9uLCBUWCIsInBvaW50Ijp7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbMzIuNzM1NTk1NywtOTcuMTA3MTA5MDddfSwiYWRkcmVzcyI6eyJhZG1pbkRpc3RyaWN0IjoiVFgiLCJhZG1pbkRpc3RyaWN0MiI6IlRhcnJhbnQgQ291bnR5IiwiY291bnRyeVJlZ2lvbiI6IlVuaXRlZCBTdGF0ZXMiLCJmb3JtYXR0ZWRBZGRyZXNzIjoiQXJsaW5ndG9uLCBUWCIsImxvY2FsaXR5IjoiQXJsaW5ndG9uIn0sImNvbmZpZGVuY2UiOiJIaWdoIiwiZW50aXR5VHlwZSI6IlBvcHVsYXRlZFBsYWNlIiwiZ2VvY29kZVBvaW50cyI6W3sidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlszMi43MzU1OTU3LC05Ny4xMDcxMDkwN10sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfSx7Il9fdHlwZSI6IkxvY2F0aW9uOmh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vc2VhcmNoL2xvY2FsL3dzL3Jlc3QvdjEiLCJiYm94IjpbNTAuODI5NjkyODQwNTc2MTcsMC4xNjc3NTY0OTc4NTk5NTQ4Myw1MC44ODIyMjUwMzY2MjEwOTQsMC4yNDMyODg5MDQ0Mjg0ODIwNl0sIm5hbWUiOiJBcmxpbmd0b24sIEVhc3QgU3Vzc2V4LCBVbml0ZWQgS2luZ2RvbSIsInBvaW50Ijp7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbNTAuODQ1NjkxNjgsMC4xOTE5NzYyOV19LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJFbmdsYW5kIiwiYWRtaW5EaXN0cmljdDIiOiJFYXN0IFN1c3NleCIsImNvdW50cnlSZWdpb24iOiJVbml0ZWQgS2luZ2RvbSIsImZvcm1hdHRlZEFkZHJlc3MiOiJBcmxpbmd0b24sIEVhc3QgU3Vzc2V4LCBVbml0ZWQgS2luZ2RvbSIsImxvY2FsaXR5IjoiQXJsaW5ndG9uIn0sImNvbmZpZGVuY2UiOiJNZWRpdW0iLCJlbnRpdHlUeXBlIjoiUG9wdWxhdGVkUGxhY2UiLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzUwLjg0NTY5MTY4LDAuMTkxOTc2MjldLCJjYWxjdWxhdGlvbk1ldGhvZCI6IlJvb2Z0b3AiLCJ1c2FnZVR5cGVzIjpbIkRpc3BsYXkiXX1dLCJtYXRjaENvZGVzIjpbIkdvb2QiXX0seyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzM4LjgyNzM1NDQzMTE1MjM0NCwtNzcuMTcyMjg2OTg3MzA0NjksMzguOTM0MzYwNTA0MTUwMzksLTc3LjAzMjEzNTAwOTc2NTYyXSwibmFtZSI6IkFybGluZ3RvbiwgVkEiLCJwb2ludCI6eyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM4Ljg5MDc2MjMzLC03Ny4wODQ3NTQ5NF19LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJWQSIsImFkbWluRGlzdHJpY3QyIjoiQXJsaW5ndG9uIENvdW50eSIsImNvdW50cnlSZWdpb24iOiJVbml0ZWQgU3RhdGVzIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkFybGluZ3RvbiwgVkEiLCJsb2NhbGl0eSI6IkFybGluZ3RvbiJ9LCJjb25maWRlbmNlIjoiTG93IiwiZW50aXR5VHlwZSI6IlBvcHVsYXRlZFBsYWNlIiwiZ2VvY29kZVBvaW50cyI6W3sidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlszOC44OTA3NjIzMywtNzcuMDg0NzU0OTRdLCJjYWxjdWxhdGlvbk1ldGhvZCI6IlJvb2Z0b3AiLCJ1c2FnZVR5cGVzIjpbIkRpc3BsYXkiXX1dLCJtYXRjaENvZGVzIjpbIkdvb2QiXX0seyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzM4LjYwMzY5NDkxNTc3MTQ4NCwtNzcuNjc3ODU2NDQ1MzEyNSwzOS4xNTc5MDE3NjM5MTYwMTYsLTc2LjUyNTkzOTk0MTQwNjI1XSwibmFtZSI6IkFybGluZ3RvbiBDb3VudHkiLCJwb2ludCI6eyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM4Ljg5MDc2MjMzLC03Ny4wODQ3NTQ5NF19LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJWQSIsImFkbWluRGlzdHJpY3QyIjoiQXJsaW5ndG9uIENvdW50eSIsImNvdW50cnlSZWdpb24iOiJVbml0ZWQgU3RhdGVzIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkFybGluZ3RvbiBDb3VudHkifSwiY29uZmlkZW5jZSI6IkxvdyIsImVudGl0eVR5cGUiOiJBZG1pbkRpdmlzaW9uMiIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbMzguODkwNzYyMzMsLTc3LjA4NDc1NDk0XSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19LHsiX190eXBlIjoiTG9jYXRpb246aHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS9zZWFyY2gvbG9jYWwvd3MvcmVzdC92MSIsImJib3giOls0Mi4zOTc0MTEzNDY0MzU1NSwtNzEuMjAyNjIxNDU5OTYwOTQsNDIuNDM2Mjk4MzcwMzYxMzMsLTcxLjEzMjI0NzkyNDgwNDY5XSwibmFtZSI6IkFybGluZ3RvbiwgTUEiLCJwb2ludCI6eyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzQyLjQxNjI0ODMyLC03MS4xNTY2Njk2Ml19LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJNQSIsImFkbWluRGlzdHJpY3QyIjoiTWlkZGxlc2V4IENvdW50eSIsImNvdW50cnlSZWdpb24iOiJVbml0ZWQgU3RhdGVzIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkFybGluZ3RvbiwgTUEiLCJsb2NhbGl0eSI6IkFybGluZ3RvbiJ9LCJjb25maWRlbmNlIjoiTG93IiwiZW50aXR5VHlwZSI6IlBvcHVsYXRlZFBsYWNlIiwiZ2VvY29kZVBvaW50cyI6W3sidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOls0Mi40MTYyNDgzMiwtNzEuMTU2NjY5NjJdLCJjYWxjdWxhdGlvbk1ldGhvZCI6IlJvb2Z0b3AiLCJ1c2FnZVR5cGVzIjpbIkRpc3BsYXkiXX1dLCJtYXRjaENvZGVzIjpbIkdvb2QiXX1dfV0sInN0YXR1c0NvZGUiOjIwMCwic3RhdHVzRGVzY3JpcHRpb24iOiJPSyIsInRyYWNlSWQiOiJjNTFhNzc0MmE5MjVhYWZjZGM2MzM2OGZkZGY2ZDcwNiJ9
+  recorded_at: Tue, 30 Jul 2024 16:51:56 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Virginia?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -511,7 +511,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Thu, 25 Jul 2024 13:38:49 GMT
+      - Tue, 30 Jul 2024 16:51:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -529,18 +529,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 5559757efa02cc753909142a57937577
+      - 79f884cc5a5e241914ab37672ca85f29
       X-Msedge-Ref:
-      - 'Ref SnR: 66a25569c2f64481aa1af86e7d1b0a5f|Ref A: 26E8C067383E4E9A8490C220BD3505D5
-        Ref B: DB3EDGE3120 Ref C: 2024-07-25T13:38:49Z'
+      - 'Ref SnR: 66a91a2c420645b7af01a93edf27c4b3|Ref A: 54007E5576CA4FDDB6803F03E20D6261
+        Ref B: DB3EDGE2618 Ref C: 2024-07-30T16:51:56Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-855j8, mapsplatform-forwardgeocoder-service-5854b89bbc-wwsxk
+      - mapsplatform-frontend-5989d449fd-l6szp, mapsplatform-forwardgeocoder-service-69c675d4f5-5dpvl
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '77'
+      - '65'
       X-Azure-Ref:
-      - 20240725T133849Z-r199894c6f4svnksuuwagq1mps000000046g000000006cab
+      - 20240730T165156Z-154b59dbc6dszzcr5m90q20f7400000000m0000000013ydx
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -548,6 +548,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Thu, 25 Jul 2024 13:38:49 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:51:56 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_lever.yml b/spec/fixtures/cassettes/create_job_lever.yml
index 2a225b06..f07f9503 100644
--- a/spec/fixtures/cassettes/create_job_lever.yml
+++ b/spec/fixtures/cassettes/create_job_lever.yml
@@ -19,11 +19,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:42 GMT
+      - Tue, 30 Jul 2024 16:28:10 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
-      - '1432517'
+      - '1477609'
       Connection:
       - keep-alive
       Strict-Transport-Security:
@@ -33,14 +33,14 @@ http_interactions:
       X-Xss-Protection:
       - 1; mode=block
       Etag:
-      - W/"15dbc5-TMDXewzNtQhkDif5BtDZT8K87dM"
+      - W/"168be9-PtUkFuKXj/26omgKM7XfE6VxSmE"
       X-Stream-Path:
       - dapi
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        [{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721638994130,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","id":"f53cae40-f605-4215-9a82-b48c5db508b5","lists":[{"text":"What you will do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance.</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Actively mentor SE/ASEs&nbsp; in the teamTranslate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environmentsImprove engineering standards, tooling and processes</li>"},{"text":"What you will need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applicationsHave expertise in at least one of Go or JavaIn-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etcExcellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"#10010 Senior Backend Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5","applyUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5/apply"},{"additionalPlain":"The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.\nThe Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.\nWe, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.\n","additional":"<div><span style=\"font-size: 10pt\">The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 10pt\">The Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.</span></div><div><span style=\"font-size: 10pt\">We, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721640901865,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","id":"ce351965-e2f9-4f8f-8cad-38fb4cd045e9","lists":[{"text":"What you will do","content":"<li>Independently responsible for the entire lifecycle of high-complexity Android projects or features including software design, development, and deployment within their team</li><li>Planning &amp; timely delivery of work within their teamImproving code structure and architecture in service of testability and maintainability</li><li>Writing, co-writing, and reviewing design documentation</li><li>Leading new language/framework POCsParticipating in the design review process, seeking and providing constructive criticism</li><li>Tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Ensuring that their team has strong sets of documentation and journals of how their design and architecture evolve over time</li><li>Ensuring predictability, quality &amp; throughput of their team's delivery</li><li>Prioritizing and valuing work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalating challenges that are outside their control but affect the team's delivery</li><li>Prioritizing work based on understanding the trade-off between quality, tech-debt, and delivery</li><li>Leading effort to work with other teams to solve problems affecting the delivery of their team</li><li>Participating in prioritization of cross teams initiatives &amp; leading those within their own team</li><li>Splitting complex engineering task into smaller components which can be developed by junior engineers in the team</li><li>Mentoring other engineers on an individual basis</li><li>Participating in the hiring process (by meeting candidates, and attending recruiting events)</li><li>Conducting engineering interviews</li>"},{"text":"What you will need","content":"<li>Should have at least 4 years of experience with Android developmentProficient in Kotlin programming, Java, and Android APIs.</li><li>Strong knowledge of Android Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standards across the teamWorking experience with popular libraries for networking, async, image loading, etc.</li><li>Well-versed with Agile methodologies, TDD, and Test Engineering &amp; Automation.</li><li><b>Bonus points if:&nbsp;</b>Have experience in Running A/B or multi-variant experiments for features that you built.</li>"}],"text":"#10279 Senior Android Developer (Logistic)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9","applyUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898011592,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"657d7112-420a-4e42-8bfd-1b790fc05155","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"#10357 Senior Software Engineer - Go-food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155","applyUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721901545426,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"87b4d0e4-219e-4ba7-9433-27220623ab69","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10358 Software Engineer - Backend (Groceries)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69","applyUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898703682,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10359 Software Engineer - Backend","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","applyUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</div>","categories":{"department":"ODS - Regions","location":"Bali","team":"East Java, Bali, Nusra Regions","allLocations":["Bali"]},"createdAt":1720778770433,"descriptionPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"73172a46-5486-4860-a256-8e17225c4a47","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transaction</li><li>Create regular report to what's happen in their respective areas toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Fresh Graduate are welcome to Apply&nbsp;</li><li>2 years relevant experience with preferable industries: top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region will be a plus</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Bali)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47","applyUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721704703939,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"885b2af9-c94a-4010-b0c4-c6ea7812039b","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b","applyUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721037961422,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"94efd0c8-e79b-41e1-aa37-a7a4c08c108f","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f","applyUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f/apply"},{"additionalPlain":"About the team\n\nOur GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n","additional":"<div><b>About the team</b></div><div><br></div><div>Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</div><div><br></div><div>Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</div>","categories":{"department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721623842937,"descriptionPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","id":"94f85d13-6fe6-43a8-96c8-4898ab75d908","lists":[{"text":"What Will You Do","content":"<li>Executing campaign creation of our merchants through our inhouse portal and assist in troubleshooting to our product managers and engineers&nbsp;</li><li>Proactively improve the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Learn to introduce beneficial business changes through well-written document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Support and coordinate with multiple stakeholders to ensure seamless workflow, update relevant changes and address any operational issues</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resources</li>"},{"text":"What Will You Need","content":"<li>Minimum 1 year of working experience&nbsp;</li><li>End to end the problem-solving mindset that can work well with stakeholders&nbsp;</li><li>Basic data analytics capability, having capability in SQL is a plus</li><li>Experience in Growth, Product Management, and Data team is a plus</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders&nbsp;</li><li>Open to acquiring new skills and taking on diverse projects</li>"}],"text":"Ads Ops Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","descriptionBodyPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908","applyUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908/apply"},{"additionalPlain":"About The Team\nArea CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales & analytics team) in the designated Areas.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Area CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales &amp; analytics team) in the designated Areas.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Semarang","team":"Central West Java Regions","allLocations":["Semarang"]},"createdAt":1720592465974,"descriptionPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","id":"f1bdce17-4ab5-49ab-9dbc-6d96a5619846","lists":[{"text":"What You Will Do","content":"<li>Support Area Head to drive consumer engagement focus areas in terms of Visibility &amp; Partnership which will deliver POI domination, POS merchants branding, standard package that will deliver Area target completed orders and active users</li><li>Managing all day to day marketing executional activities from all areas needed to deliver the consumer engagement plans. e.g. contract, PO, invoice, etc.</li><li>Ensure all consumer engagement activities in areas are delivered with a given standard of accuracy, completeness, timeliness as per the standard package and local initiatives</li><li>Externally supervise vendors/daily workers in executing merchant branding and POI domination on a regular basis</li><li>&nbsp;Internally work with direct responsibility to deliver area executions and targets by executing events, exhibits, and other activities</li><li>Good with data to develop and execute clear integrated strategies of digital marketing with clear metrics and excellent results</li><li>Responsible for setting the integrated communications plan and ensuring consistency of messaging and brand communications. Working closely with the sales, government relations, and operations team</li>"},{"text":"What This Role Needs","content":"<li>At least 2&nbsp; years of working experience in Marketing/Sales</li><li>Good understanding of local knowledge</li><li>Strong analytical and planning skills</li><li>Good communication and presentation skills</li><li>Excellent problem-solving skill with the ability to play it well independently and in a team</li><li>Good collaboration with compassion and proactiveness</li><li>Agile and fast in thinking and execution</li><li>Have exposure of working at a top global FMCG company would be a plus point</li>"}],"text":"Area CE Associate - Semarang - #10227","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","descriptionBodyPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846","applyUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720169838701,"descriptionPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><span style=\"font-size: 10pt\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","lists":[{"text":"What you will do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;</li><li>driver acquisition management</li><li>driver engagement management (loyalty &amp; retention and safety &amp; performance training)&nbsp;</li><li>driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant)</li><li>driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li><div><br></div>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Having good understanding about supply and demand planning</li><li>Having experience in managing a small team (&gt; 3 members)</li><li>Having good communication skills and good attention to detail and routine activities</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Able to handle communication in community or mass conflict&nbsp;</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written in English</li>"}],"text":"Area Operations Manager - Bekasi","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","applyUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb/apply"},{"additionalPlain":"About the team \n\nArea Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the team </b></div><div><br></div><div><span style=\"font-size: 16px\">Area Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Depok","team":"-","allLocations":["Depok","Bogor"]},"createdAt":1713768982209,"descriptionPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"18674f77-24b2-46a4-86bb-7b5e7fe71f2c","lists":[{"text":"What You Will Do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;Driver acquisition management, Driver engagement management (loyalty &amp; retention and safety &amp; performance training), Driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant), driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li>"},{"text":"What You Will Need","content":"<li>At least 5 years experience in operations/ supply/ demand generation, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Good understanding about supply and demand planning</li><li>Prior experience in managing team (&gt; 3 members)</li><li>Good communication skills and good attention to detail and routine activities</li><li>Ability to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Capability to handle communication in community or mass conflict&nbsp;</li><li>Proficiency in English both spoken and written</li>"}],"text":"Area Operations Manager (Bogor Depok)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c","applyUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c/apply"},{"additionalPlain":"About The Team\n\nOur Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners. \n\nOne of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team. \n\nOur team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">One of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"-","allLocations":["Tangerang"]},"createdAt":1716869065162,"descriptionPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","id":"8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","lists":[{"text":"What You Will Do","content":"<li>List, identify, and propose solutions to our driver partners' problems on the field and ensure their concerns are heard by following up with them</li><li>Manage offline engagement (i.e. 'kopdar') as our way to inform, reach, and engage with driver partners</li><li>Ensure all engagement programs are well executed and implemented</li><li>Handle driver support unit according to agreed operating office hours</li><li>Support implementation of Gojek's policies/programs by managing these changes</li><li>Propose activities/programs to engage our driver partners</li><li>Monitor personal metrics of engagement with driver partners, and propose solutions to increase the level of engagement</li>"},{"text":"What You Will Need","content":"<li>A Bachelor's degree (fresh graduates are welcome to apply!)</li><li>At least 1 year of experience in supply chain, preferably at a multinational company</li><li>Strong analytical thinking and problem-solving skills to effectively resolve driver-related issues</li><li>Strong interpersonal skills in order to cater and build relationships with various stakeholders</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Sharp attention to detail to increase productivity and reduce the likelihood of errors</li><li>Excellent planning and organizational abilities to ensure the area team is on track to achieve its goals</li><li>An understanding about/familiarity with the Tangerang region</li>"}],"text":"Area Operations Staff","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","descriptionBodyPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","applyUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2/apply"},{"additional":"","additionalPlain":"","categories":{"department":"ODS - Regions","location":"Balikpapan","team":"Emerging Market","allLocations":["Balikpapan"]},"createdAt":1719223321521,"description":"","descriptionPlain":"","id":"95ee9a06-a46d-43a2-a8e7-003de776404d","lists":[{"text":"What you will do:","content":"<li>Handle all the driver community, marketing, and driver care responsibilities on areas level and channel walk in center on each area;</li><li>Ensure problem solving according to agreed process &amp; based on standard operational procedure;</li><li>Manage driver’s problems and empowerment;</li><li>Coordinate with Area Operations Manager for day-to-day escalated issues around driver service and customer service to manage service time, driver and customer satisfaction;</li><li>Developing the marketing strategy for the company in line with company objectives;</li><li>Conceptualizes events, exhibits and other below the line marketing based on the marketing plan, and evaluate the effectiveness of all marketing activities;</li><li>Maintain effective internal communications to ensure that all relevant company functions are kept informed of marketing objectives.</li>"},{"text":"What you will need:","content":"<li>Having a minimum of 3 years experience in related fields;</li><li>Bachelor degree from top university any well-known universities from each region with GPA &gt; 3.2 or equivalent;</li><li>Passionate about community development, having relevant previous experience would be preferred;</li><li>Experience launching community initiatives (building an online forum, launching an ambassador program, creating an event series, etc.);</li><li>Ability to identify and track relevant community and market metrics;</li><li>Excellent verbal communication and writing skills;</li><li>Having a basic of data analytics;</li><li>Willing to relocate to a selected area.</li>"}],"text":"Area Operations Supervisor - Balikpapan","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d","applyUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d/apply"},{"additionalPlain":"About the team\n\nThis position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team. \n","additional":"<div><b>About the team</b></div><div><br></div><div>This position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team.&nbsp;</div>","categories":{"department":"ODS - Regions","location":"Makassar","team":"Emerging Market","allLocations":["Makassar"]},"createdAt":1721716492787,"descriptionPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","description":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","id":"20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","lists":[{"text":"What Will You Do","content":"<li>Develop and implement procedures for effective sales support administration;</li><li>Monitor and analyze sales support team performance to identify areas for improvement and implement strategies to increase efficiency;</li><li>Ensure all sales inquiries and issues are addressed promptly and accurately, with a focus on improving merchant satisfaction &amp; topline sales metrics;</li><li>Coordinate with the merchant sales team to streamline sales processes and remove obstacles in the sales cycle;</li><li>Execute GoFood onboarding timely &amp; ensure that there is no backlog</li><li>Able to understand KYC follow up reasons based on FAQ and able to know when to escalate</li><li>Collaborate with other departments to ensure sales and marketing strategies are aligned and support the overall goals of the organization;</li><li>Assist in the development and implementation of sales policies and practices that drive sales effectiveness.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree in Business Administration, Marketing, or a related field;</li><li>Minimum of 3 years of experience in sales support, account management, customer service, sales-marketing administration related or a supervisory role within a sales-focused organization;</li><li>Strong customer/merchant partner focus and project management skills preferred;</li><li>Has data reporting skills, preferred both Bahasa Indonesia and English;</li><li>Strong analytical and problem-solving abilities by utilizing e.g. Google Sheet, etc;</li><li>Detail and deadline oriented;</li><li>Strong stakeholder management and cross-functional collaboration;</li><li>Able to adapt in a fast-changed environment.</li>"}],"text":"Area Sales Support Supervisor (Sulampa)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","descriptionBodyPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","applyUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450/apply"},{"additionalPlain":"About The Team\n\nOur tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!  \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">Our tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!&nbsp;&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697204557563,"descriptionPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","description":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","id":"56966262-038f-497f-84c1-f360a9440c55","lists":[{"text":"What You Will Do","content":"<li>Manage tax compliance matters; including preparation of monthly and annual tax calculation/payment/returns, i.e. WHT, VAT, CIT)</li><li>Manage and advise day-to-day business initiatives including decisive actions toward dynamic business products</li><li>Manage and handle restructuring projects independently with supervision from the AVP of Tax</li><li>Able to communicate and align with relevant stakeholders within the group</li><li>Monitoring any tax regulation updates, identifying relevant business areas that may be impacted, and planning the risk mitigation strategy</li><li>Able to support the litigation process and assessment of risks</li><li>Able to support the advocacy initiatives within the relevant external organizations.</li>"},{"text":"What You Will Need","content":"<li>S1 Bachelor of Economics (majoring in accounting or corporate finance) or Bachelor of Social Finance (Majoring in Fiscal Administration) </li><li>Minimum 5 years of working experience in the taxation field</li><li>Strong interpersonal, analytical, communication, and presentation skills with advanced command of written and spoken English</li><li>Strong technical skills in tax, accounting, and corporate finance</li><li>Ability to work in a fast-paced, rapidly changing, and high-growth environment</li><li>Able to work independently and in a team</li>"}],"text":"Assistant Tax Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","descriptionBodyPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55","applyUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721353652294,"descriptionPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","description":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","id":"325ee617-30f3-41c1-a022-6577bd82faf0","lists":[{"text":"What You Will Do","content":"<li>Collecting and importing data from various sources into databases.</li><li>Cleaning and preprocessing data to ensure accuracy and consistency.</li><li>Analyzing datasets to identify trends, patterns, and insights.</li><li>Creating and maintaining data visualizations and dashboards.</li><li>Generating regular and ad-hoc reports for stakeholders.</li><li>Collaborating with team members and stakeholders to understand data needs and requirements.</li><li>Monitoring data quality and integrity, addressing any discrepancies.</li><li>Utilizing programming languages (e.g., SQL, Python) and tools (e.g., Sheet) for data manipulation and analysis.</li>"},{"text":"What You Will Need","content":"<li>Technical Skills: Proficiency in SQL, Python, and Sheet for data manipulation and analysis.</li><li>Analytical Skills: Strong analytical and problem-solving skills to interpret data and create actionable insights.</li><li>Reporting Tools: Familiarity with tools for generating reports, such as Sheet, Metabase, or Looker Studio.</li><li>Communication Skills: Ability to communicate findings and insights effectively to non-technical stakeholders..</li>"}],"text":"Business Analyst - GoPay","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt;\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt;\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","descriptionBodyPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0","applyUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716278898371,"descriptionPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","description":"<div><span style=\"font-size: 16px\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","id":"2242125a-7155-4353-bc79-473d237d6808","lists":[{"text":"What You WIll Do","content":"<li>Be the expert in using data to measure and analyze business performance.</li><li>Explore business issues/opportunities, uncover insights and/or identify targeted areas for business growth.</li><li>Lead new data analytics capability rollouts and/or data-led initiatives throughout organization.</li><li>Monitor key metrics and alert the business on potential issues.</li><li>Analyze operational efficiency and build business models to guide decision-making.</li><li>Design market/business intelligence reports and performance measurement dashboards to share with senior management.</li><li>Able to analyze business performance following the analysis framework.</li><li>Able to create reports/ dashboards individually.</li><li>Collaborates with business stakeholders to gather requirements and deliver actionable insights.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Statistics, Business Administration, or a related field.</li><li>2-5 years of experience in a BI or analytics role.</li><li>Proficiency in SQL and database management systems like MySQL, SQL Server, or Oracle.</li><li>Advanced knowledge of data modeling and data warehousing concepts.</li><li>Strong understanding of business processes and the ability to translate business requirements into technical solutions.</li><li>Familiarity with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Experience with BI reporting tools and dashboard development.</li><li>Proven ability to work with cross-functional teams and manage stakeholders.</li><li>Familiarity with business operations in the field.</li>"}],"text":"Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","descriptionBodyPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808","applyUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808/apply"},{"additionalPlain":"About The Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119647983,"descriptionPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><b style=\"font-size: 16px\">Job Scope</b></div><div><span style=\"font-size: 16px\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px\">6 Months Challenge</b></div><div><span style=\"font-size: 16px\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","id":"9a8977f6-ea32-40e0-bb09-d3330c40d056","lists":[{"text":"What You Will Do","content":"<li>Monitor performance metrics and adjust processes as needed</li><li>Build relationships with stakeholders to support process optimization initiatives</li><li>Leverage technology to automate tasks and improve accuracy</li><li>Focus on enhancing customer experience in building automated support processes</li><li>Ensure high-quality service delivery to customers</li><li>Implement changes to streamline workflows and enhance efficiency</li>"},{"text":"What This Role Needs","content":"<li>At least 5 years working experience in related field</li><li>Strong analytical and problem-solving skills</li><li>Experience in process optimization and workflow management</li><li>Proficiency with automation tools and technology</li><li>Excellent communication and coordination abilities</li><li>Ability to prioritize tasks and manage time effectively</li><li>Knowledge of customer experience best practices</li><li>Familiarity with fintech industry standards and trends</li><li>Collaborative mindset to build relationships with stakeholders</li>"}],"text":"Business Operations Analyst (Trust and Safety) - GoPay - #10311","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><b style=\"font-size: 16px;\">Job Scope</b></div><div><span style=\"font-size: 16px;\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px;\">6 Months Challenge</b></div><div><span style=\"font-size: 16px;\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","descriptionBodyPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056","applyUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264950378,"description":"","descriptionPlain":"","id":"73e71b86-d53f-4841-92ec-4bd09a0ef479","lists":[{"text":"What You Will Do","content":"<li>explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across the Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs..</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Data Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479","applyUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716265340466,"description":"","descriptionPlain":"","id":"36d71dff-c9ac-44b8-b870-f74d941bd7d3","lists":[{"text":"What You Will Do","content":"<li>Design and implement complex data solutions, architecting data systems, and driving technical initiatives.</li><li>Optimize data infrastructure for performance, scalability, and reliability - working with large-scale data volumes &amp; distributed systems.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Provide technical guidance and support to ensure the successful delivery of data projects, including troubleshooting and resolving technical challenges.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>5+ years of experience in data engineering, software engineering, or a similar role.</li><li>Expertise in programming languages such as Python, Java, or Scala.</li><li>Advanced knowledge of SQL, database management systems, and data warehousing concepts.</li><li>Extensive experience with big data technologies and distributed systems.</li><li>Proven track record of designing and implementing complex data pipelines and ETL processes.</li><li>Deep understanding of cloud-based data technologies and best practices.</li><li>Leadership abilities to mentor junior team members and lead technical initiatives.</li><li>Strong problem-solving and troubleshooting skills.</li><li>Ability to communicate technical concepts effectively to both technical and non-technical stakeholders.</li>"}],"text":"Data Engineer Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3","applyUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3/apply"},{"additionalPlain":"About the Team\n\nThe Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience. \nAs a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience.&nbsp;</div><div>As a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1717749466111,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","description":"<div><span style=\"font-size: 10pt\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","id":"d93a7524-8ab9-4499-9f04-0876fcafa529","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain performance management dashboards and visualizations.&nbsp;</li><li>Provide regular analysis on operational performance metrics including transactions, conversion rate, lead quality, cost efficiency, retention, and KPI tracking to guide decision-making and devise proactive solutions.&nbsp;</li><li>Collaborate across teams to drive Operational Excellence (OPEX) and Continuous Improvement Process (CIP) initiatives, identifying growth opportunities for product, customer, driver, and optimization.&nbsp;</li><li>Support senior management with clear and concise presentations of complex data sets for informed decision-making.&nbsp;</li><li>Build, automate, and enhance reporting, data logging, and data pipelines for availability, integrity, accuracy, and reliability, ensuring security and compliance.&nbsp;</li><li>Assist in report compilation, issue investigation, and liaison with internal and external stakeholders for regulatory compliance.</li>"},{"text":"What You Will Need","content":"<li>Bachelors' Degree in Economics, Computer Science, Engineering, Mathematics or Statistics.&nbsp;</li><li>Minimum 5 years experience with 3+ years of relevant experience in analytics and product/process improvement.&nbsp;</li><li>Proficient in analyzing large datasets and translating quantitative findings into actionable insights.&nbsp;</li><li>Excellent understanding of analytics, computational modeling, business needs analysis, data visualization, and stakeholder management.&nbsp;</li><li>Resilience and initiative in a fast-paced, dynamic environment&nbsp;</li><li>Proficient in SQL; experience in BI tools such as Tableau, Metaforce, Python or Looker is a plus&nbsp;</li><li>Prior experience demonstrating strong stakeholder engagement and vendor management skills is a plus</li>"}],"text":"Data Operations Analyst","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529","applyUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Internship","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719909376581,"descriptionPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","id":"816f2d4c-5ff6-4e83-8697-9c25df599409","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li><b>Fresh Graduates </b>from computer science, mathematics, or statistics<b>&nbsp;</b>(Students on final semester are also preferred)</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Data Scientist Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409","applyUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409/apply"},{"additionalPlain":"Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.\n","additional":"<div><span style=\"font-size: 10pt\">Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718963848611,"descriptionPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","description":"<div><span style=\"font-size: 9pt\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","id":"5d07cd21-8826-4de7-9ad4-15909a0c5c37","lists":[{"text":"What you will do","content":"<li>Devise and implement tailored digital marketing strategies for GoRide, GoCar, GoSend, and GoShop</li><li>Analyze market trends to identify growth opportunities and refine strategies accordingly</li><li>Collaborate cross-functionally to ensure alignment with business goals</li><li>Monitor and evaluate campaign performance to drive optimization</li><li>Stay updated on industry trends and technologies to drive innovation</li><li>Manage relationships with external partners and agencies to support initiatives</li><li>Contribute to overarching marketing strategies and brainstorming sessions.</li><div><br></div>"},{"text":"What you will need","content":"<li>3+ years of digital marketing experience</li><li>Proficiency in digital marketing tools and platforms such as Google Adwords, Meta, TikTok Ads, Google Analytics &amp; Data Studio/Looker</li><li>Strong analytical, communication, and problem-solving skills</li><li>Bachelor's degree in Marketing, Communications, or related field</li><li>Fluency in English. </li><div><br></div>"}],"text":"Digital Marketing Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","descriptionBodyPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37","applyUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37/apply"},{"additionalPlain":"The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1722240835278,"descriptionPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","description":"<div><span style=\"font-size: 9pt\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","id":"eb38692a-8133-4cd2-a793-f5d75ee8841a","lists":[{"text":"What You Will Do","content":"<li>Accountable for leading the driver onboarding and support team, ensuring a quick and seamless experience for driver-partners at the GoHub</li><li>Management of day-to-day operations of the team, including communications and KPI performance management</li><li>Drive results through strong internal and external collaboration to improve the quality and efficiency of the team</li><li>Support &amp; drive operational requirements, to achieve and exceed team productivity and service level targets</li><li>Responsible for the design, deployment and maintenance of processes arising from new product launches and enhancement to existing process flows</li><li>Understand reporting needs and provide appropriate data analysis on performance metrics for stakeholders</li><li>Work with relevant stakeholders to identify and prioritize improvement initiatives and other cross-functional projects</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience as an operations manager in a contact center / frontline customer service operations</li><li>Experience in managing teams, motivating, coaching and inspiring team members to achieve excellent customer experience</li><li>Address conflicts and interpersonal issues within the team professionally and diplomatically</li><li>Ability to make informed decisions under pressure, considering both short-term and long-term implications</li><li>Keen eye for detailed process steps &amp; identification of gaps/opportunities</li><li>Strong stakeholder and project management capabilities</li><li>Efficiently manage time, resources, and priorities to ensure productivity and meet deadlines</li><li>Keep customer needs in mind when making decisions and managing operations</li><div><br></div>"}],"text":"Driver Care Lead, Hub Operations","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","descriptionBodyPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a","applyUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a/apply"},{"additionalPlain":"About Us\n\nWe are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nAlong with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1714628452648,"descriptionPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px\">&nbsp;</span></div><div><span style=\"font-size: 16px\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","id":"dfe98505-36d8-4467-aa36-df8599ab69d8","lists":[{"text":"What You Will Do","content":"<li>Assess and manage team performance through staff meetings, one on ones, and quarterly assessments</li><li>Mentor your engineers to ensure their growth and engagement in the team, evaluate team workload and develop a staffing plan, and assign projects and balance workload to ensure continuous delivery and higher predictability</li><li>Serve as primary interface to staffing team, creating job descriptions, identifying sources for candidates, conducting interviews and shepherding candidates through the process</li><li>Lead a team of Software Engineers focused on improving velocity and impact across Gojek’s diverse project areas and platforms</li><li>Become a partner to Product Managers on deciding vision, strategy and OKRs</li><li>Provide technical expertise throughout the product life cycle including design, implementation, and delivery of scalable build/test/release infrastructure</li>"},{"text":"What You Will Need","content":"<li>Having at least 8 years of relevant software development experience preferably with experience in data products, also at least 2 years of leading and mentoring an engineering team to success</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, TDD and Test Engineering, and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate dependency risks</li><li>Ability to review the code and ensure code maintainability as part of new product enhancements.</li>"},{"text":"Bonus Points If","content":"<li>Understanding in data modeling for data warehouse, relational database, and non-relational database</li><li>Understanding in batch and stream data pipeline; Beam, Flink, Spark</li>"}],"text":"Engineering Manager - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px;\">&nbsp;</span></div><div><span style=\"font-size: 16px;\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8","applyUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8/apply"},{"additionalPlain":"About the Team\n\nThe Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721370013113,"descriptionPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","id":"178ba514-705f-4f0b-9e48-fe917c47a95b","lists":[{"text":"What You Will Do","content":"<li>Continuously monitor, review, maintain, and improve security controls that are used to secure GoTo enterprise IT systems and SaaS services;</li><li>Review and implement initiatives to improve the security posture of GoTo enterprise IT systems and SaaS services;</li><li>Perform security hardening on GoTo IT systems and SaaS services;</li><li>Support the remediation of relevant security issues relevant to GoTo corporate IT systems and SaaS services;</li><li>Provide answers and recommendations to security-related questions, queries, and requests related to GoTo enterprise IT systems and SaaS services;</li><li>Develop, review, and improve technical documentation and reports relevant to the security controls used by GoTo corporate IT systems and SaaS services.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, networking, and general security concepts (a bachelor's degree or higher is a plus).</li><li>At least 5 years of experience in cyber security, preferably with hands-on experience in implementing and maintaining the security of enterprise grade IT systems and SaaS services, e.g., Google Workspace, Microsoft 365, Slack, SAP, or Atlassian;</li><li>Proven hands-on experience in the configuration and troubleshooting of enterprise security solutions, e.g., EDR, MDM, DLP, Firewall, and/or SASE;</li><li>Proven hands-on experience in the management and security of enterprise collaboration tools such as Google Workspace, Microsoft 365, or Lark;</li><li>Coding and scripting skills especially for automation is highly desired;</li><li>Ability to develop clear and concise documentation and reports.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Enterprise Information Security Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","descriptionBodyPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b","applyUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b/apply"},{"additionalPlain":"About The Team\n\nCost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Cost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.</div>","categories":{"commitment":"Permanent","department":"FinTech - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718852731439,"descriptionPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","id":"60283bc5-9f60-400a-8289-bcbe332fbc09","lists":[{"text":"What You Will Do","content":"<li><b>Planning</b>: Work closely with the budget owner to prepare annual budget planning, re-forecast, rolling forecast on a periodic business cycle. Review budget activities completed by the budget owner with accurate baseline, information, and proper justification</li><li><b>Controlling</b>: Responsible for reviewing and approving each spending related to Opex and Capex according to the applicable Expense Management PolicyWork closely with the budget owner to ensure each spending request is based on business requirements, supported by budget availability, and budget transfer process (if required). Collaborate with the other stakeholders in building the right cost base e.g., Procurement, Budget owner, etc.</li><li><b>Monitoring</b>: Create and refine report in order to provide the right data and information to the CFO, FBP and Budget Owner to analyze the actual spends against the available budget on monthly basis with a pre-defined report including its associated drivers. Understand the variance including the explanation and/or justification from the Budget Owner whenever the spend exceeded the approved budget. Continue to work closely with the Budget Owner in supporting the identification of risks &amp; opportunities for cost-efficiency purposes. Highlight key financial issues and deliver the proposed solutions to the stakeholders, provide insightful financial analysis on a regular and ad-hoc basis such as but not limited to topline daily/weekly tracker, business unit performance review, and other financial ratios analysisIn certain circumstances, this candidate will work with Cost Management Head to support the entire products under GoTo Financial product or Function group.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's Degree in Accounting / Finance/ Business, or equivalent educational background</li><li>Minimum 5 years of working experience in Finance Business Partner / Cost Control areas</li><li>Able to build a financial model, proficiency in Microsoft Excel and Gsheet/Gdocs</li><li>Strong business, data-driven acumen, and ability to work with big database</li><li>Able to manage multiple stakeholders across various levels of seniority</li><li>Strong project management skills to manage complex projects; able to prioritize multiple internal and external stakeholders; and able to drive consensus</li><li>Strong team player; possesses team synergy skills with a high level of enthusiasm in collaborating with cross-teams</li><li>Able to work independently and high attention to detail with swift execution</li><li>Proficiency with Finance / Accounting tools (e.g. SAP and ERP) is a plus</li><li>Fluent in English (written and spoken)</li>"}],"text":"Financial Controller Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","descriptionBodyPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09","applyUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09/apply"},{"additionalPlain":"About the team \n\nThe Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. \n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. </div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721025492852,"descriptionPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","id":"a9daeacc-5dda-4735-ad7b-db35eb7593a6","lists":[{"text":"What you will do","content":"<li>Support Compliance and Regulatory Affairs matters in GoTo Financial Services operations, which includes but is not limited to business/product reporting and approval process with the regulators, compliance advisory assistance to business unit, as well as technical regulatory assessment</li><li>Provide Compliance advisory assistance for Financial Services operations, in both consumer and merchant-facing operation</li><li>Create and maintain the latest update of Financial Services regulations databases and provide/disseminate assessments on such regulations to the internal units in GoTo Financial</li><li>Provide assistance and support to the Head of Compliance and Senior Manager of Financial Services Compliance in any external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders</li><li>Give continuous support on the creation, standardization, and implementation of Financial Services Compliance, policies, terms &amp; conditions, internal working procedures, and standard operational guidelines</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law and Accounting. Having a master’s degree would be an advantage.</li><li>Possessing certifications in Risk Management/ IT Audit will be an advantage.</li><li>At least 4 years of mixed experience in the area of payment policy/ regulatory compliance.</li><li>Intermediate level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks, proactively choose the best solutions, and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including builds credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"FinServ Compliance Officer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6","applyUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705377654170,"descriptionPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","id":"a3543985-6d2c-45cf-84f7-312ec7efed36","lists":[{"text":"What Will You Do","content":"<li>Write and deploy code that's clear, concise, performant, tested, and easy to understand by other teams and engineers</li><li>Participate in design reviews and own feature development from end to end</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices</li><li>Deep dive and debug production issues across services and levels of the stack when needed</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently</li>"},{"text":"What Will You Need","content":"<li>5+ years experience building consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Proficiency with one or more programming languages like Java, Go, and Kotlin.</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, asynchronous programming, fault tolerance and monitoring, performance, feature flags</li><li>Understanding how mobile/web applications interact with back-end and other systems. Experience in building frontend UIs is a bonus</li><li>Good understanding of SQL/NoSQL databases</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, GCP</li><li>Excellent verbal and written communication skills</li><div><br></div>"}],"text":"Full Stack Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","descriptionBodyPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36","applyUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36/apply"},{"additionalPlain":"About the Team :\nWe are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \nThis includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team :</b></div><div><span style=\"font-size: 10pt\">We are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><span style=\"font-size: 10pt\">This includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><span style=\"font-size: 10pt\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718186798651,"descriptionPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","id":"6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","lists":[{"text":"What You Will Do","content":"<li>Build highly reliable frontend apps through appealing visual design with API integrations to support continuing increases in adoption of the products within Gojek</li><li>Work with engineers to understand the nature and background of the problems.</li><li>Work closely with all Data Platform teams to develop and rollout high quality products</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Contribute to improving team relatedness, and helps build a culture of camaraderie</li><li>Continuously refactor applications to ensure high-quality</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript.</li><li>Solid command over React JS with the flavor of TypeScript.</li><li>Keen design and UX sense to analyze and understand the designs and wireframes.</li><li>Good understanding of common web security threats and practices along with OWASP 10.</li><li>Experience with <a href=\"http://node.js\" class=\"postings-link\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server.</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management.</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Fullstack Engineer - Engineering Platforms","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt;\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt;\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","descriptionBodyPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","applyUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720422707435,"descriptionPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","description":"<div><span style=\"font-size: 10pt\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","id":"1a011faf-f8c7-4531-b2ed-c3837dd521f0","lists":[{"text":"What you will do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What you will need","content":"<li>At least 5 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closing</li><li>Excellent in contract and commercial negotiation process</li>"},{"text":"About the team","content":"<li>Ready to join a team that shapes the future of new leading transformation in Gojek business as GoCorp Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in GoCorp platform for businesses to manage employees’ transport needs with Gojek services. </li>"}],"text":"GoCorp Sales Senior Manager (Enterprise & SMB)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt;\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","descriptionBodyPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a011faf-f8c7-4531-b2ed-c3837dd521f0","applyUrl":"https://jobs.lever.co/GoToGroup/1a011faf-f8c7-4531-b2ed-c3837dd521f0/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</div><div>We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</div><div>Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718006842841,"descriptionPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","id":"7d1c915f-ac53-4a2c-887a-41bbbda48a26","lists":[{"text":"What You Will Do","content":"<li>Execute design tasks such as layout composition, image editing, typography, and color correction</li><li>Assist in the development of design concepts for various marketing collateral, including digital advertisements, print and digital materials, and more</li><li>Support the Art Director to provide visual assets for video and key visuals productions</li><li>Think creatively to generate visuals that connect with target audiences</li>"},{"text":"What You Will Need","content":"<li>A bachelor’s degree, with 3 years of experience in a related field</li><li>Proficiency in design software such as Adobe Creative Suite (Photoshop, Illustrator, and Premier), with a basic understanding of design principles and techniques</li><li>A portfolio showcasing examples of design work</li><li>Strong attention to detail and a passion for visual storytelling, with the ability to create compelling designs that resonate with the target audience</li><li>A can-do attitude with a determination to see tasks through to completion</li><li>Enthusiasm for design and a proactive attitude, with a desire to contribute ideas, and solve problems creatively</li>"}],"text":"Graphic Designer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","descriptionBodyPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26","applyUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26/apply"},{"additionalPlain":"About The Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Growth Analyst role will be reporting directly to the Head of Consumer Acquisition & Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Growth Analyst role will be reporting directly to the Head of Consumer Acquisition &amp; Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Consumer Experience","allLocations":["Jakarta"]},"createdAt":1721795385137,"descriptionPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","description":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","id":"5f86f9c4-80bc-437f-b09c-b61fd85c27eb","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Drive actionable insights recommendation such as making funnel conversion analysis, cohort analysis, long-term trends, user segmentation, etc.</li><li>Identify the business need and generate analysis&nbsp;</li><li>Create and manage dashboards and data pipelines to monitor metrics to measure business performance</li><li>Working closely with the Business team and other data team (Data Engineer, Business Intelligence) to implement data solution</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 2 years of working experience in data analytics field</li><li>Proficiency in data analysis tools, SQL. Strong analytical skills to interpret complex data sets and extract actionable insights.</li><li>High proficient in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficient in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Data Management: Familiarity with data collection, storage, and management best practices.&nbsp;</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li>"}],"text":"Growth Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb","applyUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb/apply"},{"additionalPlain":"About the Team\n\nThe Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720079397618,"descriptionPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","id":"9bc8bd8a-cadc-4942-81c4-193773a294df","lists":[{"text":"What You Will Do","content":"<li>Design and own growth strategy of GoPay Later product; make data-driven business decisions on a regular&nbsp;</li><li>growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps, and actual customer insights</li><li>Test and validate solutions through a proper experimentation process</li><li>Liaise with other analytical chapters within the Financial Services Platform as well as across Gojek such as Data Science, Data Engineering, Data Governance, Risk Analytics, etc, to ensure that initiatives are aligned and data integrity standards are adhered to.</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 2 years of working experience in an analytical role (data analyst / BI/data science/statistician, etc)</li><li>Strong SQL skills with expertise in either Excel/Python/R</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps</li><li>Strong project management skills to manage projects; able to work together with relevant units, also can manage and prioritize multiple internal stakeholders</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team</li>"}],"text":"Growth Analyst - GoPay Later","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","descriptionBodyPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df","applyUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713765081862,"descriptionPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","description":"<div><span style=\"font-size: 10.5pt\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","id":"761415aa-89b7-4ffb-a19b-2b91ac4243b4","lists":[{"text":"What You Will Do","content":"<li>Lead the strategy and growth function for GoModal. You will be collaborating with the Marketing &amp; Product teams on a daily basis.</li><li>Maintain rigor in analytical excellence in terms of data analytics, A/B test design, and appropriate statistical tests across the product funnel from acquisition, adoption, retention to monetization.</li><li>Discover growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps and actual customer insights.</li><li>Analyze our complex and ever-growing data, present insights, and propose strategic options to management to drive business decisions.</li><li>Test and validate solutions through proper experimentation process.</li><li>Importantly, using data to identify growth opportunities and problem solve so as to achieve business goals with metrics such as conversion rates of WL to submit KYC, adoption rate &amp; GTV (disbursement)</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 4 years of working experience in a growth or product role (growth marketing, data analyst, BI, strategy, etc).</li><li>Strong project management skill to manage complex projects; also can manage and prioritize multiple internal and external stakeholders.</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps.</li><li>Experienced planning, designing, and executing experiments. Also comfortable working with frequentist statistics to analyze experiment results.</li><li>Strong data visualization and data storytelling skills.</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team.</li><li>Preferred but not required: Strong SQL skills with expertise in either Excel/Python/R&nbsp;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Growth Lead (Merchant Lending)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","descriptionBodyPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4","applyUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714985249008,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","id":"2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Introduce beneficial business changes through well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve the business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resourcesProactively improve the operation process in the team and act on how to drive a faster, more effective, and efficient execution process through third-party tools or in-house service</li>"},{"text":"What You Will Need ","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience&nbsp;</li><li>Data analytics capability, have a good knowledge of SQL and experimentation processes; High Proficiency in Python and R is a plus</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Planning & Operation - GoFood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","applyUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e/apply"},{"additionalPlain":"About the Team \n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717479647909,"descriptionPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","id":"1fad1d82-dc7b-4d5a-b0d0-eb4678350242","lists":[{"text":"What You Will Do","content":"<li>Lead and Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Work closely with the Product, Marketing, Sales, Research, and Intelligence teams to understand merchant pain points and define the solution as well as Data, Ads, and Operation teams in the development and implementation of initiatives and strategies</li><li>Prepare reports of key merchant metrics analysis as a basis of rationale and recommendations to upper management, including CxOs of Gojek and GoTo Group</li><li>Conduct competitive benchmarking and analysis with local and international counterparts</li><li>Introduce beneficial business changes through a well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience</li><li>Strong critical thinking, coordination, and stakeholder management skills to drive analysis and cross-collaboration independently</li><li>Data analytics capability have a good knowledge of SQL and experimentation process; High Proficiency in Python and R is a plus</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also being a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Strategy Manager - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","descriptionBodyPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242","applyUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719458638459,"descriptionPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","description":"<div><span style=\"font-size: 10pt\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","id":"b68a9eb5-f615-441a-b04c-2d2c6a9d4703","lists":[{"text":"What You Will Do","content":"<li>Perform development and review of Business Continuity Management Framework and its supporting policies;</li><li>Strategize, coordinate, and provide challenge and advisory in the implementation of Business Continuity Programs such as BCP, BCP testing, Crisis Management exercise, and ways of integrating Business Continuity concept and awareness in the operational of business and support functions;</li><li>Respond to audit and regulatory requirements on BCM;</li><li>Design and deliver BCM communications and clinic sessions;</li><li>Provide Business Continuity update report to Management</li><li>Facilitate and support the execution of the plans at the time of a crisis event.</li>"},{"text":"What You Will Need","content":"<li>Minimum bachelor’s degree in relevant discipline from a reputable university</li><li>Minimum 8 years of Business Continuity Management experience in prominent consulting firms and/or multinational companies</li><li>Growth mindset, analytical, assertive and good interpersonal skill</li><li>Relevant BCM certifications&nbsp;</li><li>Good competency in English, verbal and written.</li>"}],"text":"Head of Business Continuity Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","descriptionBodyPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703","applyUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703/apply"},{"additionalPlain":"Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717651947726,"descriptionPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><span style=\"font-size: 16px\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"c838dc08-24e8-417c-9d70-a617bc58e200","lists":[{"text":"Responsibilities","content":"<li>Gojek is looking for an experienced technologist with a passion &amp; understanding of technology to lead its transportation product. Transport is one of the flagship products in GOJEK superapp. It is launched in Indonesia, Singapore and Vietnam.</li><div><br></div><li>As Head of Engineering of Transport, you will partner with GOJEK VP, Senior VP of technology, Transport Head of Business, Group Product Manager and other business stakeholders in the company to formulate a business strategy for Transport. You will work closely with PMs and Tech Leads in Transport to realize this strategy to make GOJEK a dominant player in markets.</li><div><br></div><li>Strategic thinking and strong business acumen along with deep technical expertise are essential in this role. We expect you to be well-versed in current technological trends and familiar with a variety of business concepts. If you are also an excellent communicator and public speaker, we’d like to meet you.</li><div><br></div><div>What you will do</div><div><br></div><li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Setup growth paths for the team and engage them in processes and practices that shall help scale engineering</li><li>Collaborate with cross functional teams and stakeholders (Business, Product, Data, UX, Platform, Devops etc.) to unlock the next phase of business growth.</li><li>Provide technology leadership to the team and foster engineering excellence.</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"Experience and Skills","content":"<li>Should have at least 9 years of hands-on experience in designing, developing, testing and deploying applications at scale.</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus.</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation.</li><li>Experience as people manager and passionate towards building and growing a high functioning team.&nbsp;</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions.</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities.</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Head of Engineering - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px;\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px;\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px;\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px;\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200","applyUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720423194904,"descriptionPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","description":"<div><span style=\"font-size: 10pt\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","id":"43e7dcf0-4b25-486e-b366-e2311bcb0335","lists":[{"text":"What you will do","content":"<li>Develop comprehensive sales strategies and oversee the end-to-end planning process to ensure optimal results while maintaining efficiency levels.</li><li>Define Objectives and Key Results (OKRs), metrics, and targets for the sales team to drive performance and success.</li><li>Design and implement incentive schemes, conduct end-to-end calculations, and perform industry benchmarking to enhance sales effectiveness.</li><li>Lead the go-to-market sales strategy for special projects and new products, aligning with partner needs and market demands.</li><li>Utilize data-driven analysis to derive actionable insights, fostering accelerated growth and increased operational efficiency.</li><li>Collaborate cross-functionally with product, marketing, sales, and other stakeholders to align strategies derived from data-driven analysis and execute plans effectively.</li><li>Represent the Sales Strategy team in industry events, trainings, and workshops as necessary Provide regular and ad-hoc impact reports and analyses to senior management, offering insights into performance and growth opportunities for the business.</li>"},{"text":"What you will need","content":"<li>5 years+ relevant working experience in strategy,&nbsp; business development, management consulting or other related roles that require strong analytical skills, problem-solving, and business acumen</li><li>A structured and analytical thinking process to develop frameworks, project charters and priorities</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Proficiency in basic modeling - market sizing, business projection, scenario analysis.</li><li>Have good presentation skills - esp. the ability to present during problem solving session with other stakeholders (working-level or leadership)&nbsp;</li><li>Solid track record of stakeholder management</li><li>Proficiency in SQL/query is preferred, but not mandatory (still essential in executing the role, and will need to learn basic SQL on-the-job)</li>"},{"text":"About the team","content":"<li>Ready to join a team that shapes the future of new leading transformation in Gojek business as GoCorp Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in GoCorp platform for businesses to manage employees’ transport needs with Gojek services. </li>"}],"text":"Head of GoCorp Strategy & Planning","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt;\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","descriptionBodyPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/43e7dcf0-4b25-486e-b366-e2311bcb0335","applyUrl":"https://jobs.lever.co/GoToGroup/43e7dcf0-4b25-486e-b366-e2311bcb0335/apply"},{"additionalPlain":"About The Team\nYou will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">You will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718871657577,"descriptionPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","id":"6dc20c4e-4d40-4f57-a138-4776013e454e","lists":[{"text":"What You Will Do","content":"<li>Oversee CS, Telesales, KYC, collection and FI team and Ops projects for our BNPL and cashloan product.&nbsp;</li><li>Develop &amp; Optimize Processes - Scale new and existing processes to allow the business to efficiently operate in Indonesia</li><li>Analytics - Analysis and tracking of onboarding, merchant experience and technical issues, risk management etc</li><li>Strategy - Choose which projects to prioritize, and set a timeline to reach goals quickly</li><li>Tool Improvements - Proactively search for new tools or ways which could improve a seamless support and setup experience, for both, merchant and buyer</li><li>Be fast, resourceful, and take initiative - Take ownership of regional commerce operations and do everything you can to support and enhance the quality of our services</li>"},{"text":"What This Role Needs","content":"<li>Min. 7 years experience in tech startup/fintech industry</li><li>Experience in operations strategy, sales strategy and product management is a big plus</li><li>Proven success in dynamic and complex environments, with a proven ability to rally teams and influence at all levels</li><li>Deep analytical skills, with high capacity to think strategically about complex issues, evaluate alternatives, and make compelling recommendations based on proven business case analysis</li><li>Outstanding communication skills, both verbal and written</li><li>Ability to lead complex and strategic initiatives and communicate effectively with technical teams</li><li>Ability to collaborate with various departments by utilizing superior relationship-building skills, interpersonal skills, and influence</li>"}],"text":"Head of Operation - Consumer Lending - #10162","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","descriptionBodyPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e","applyUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705905810213,"descriptionPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","description":"<div><b><span style=\"font-size: 18px\">About The Role</span></b></div><div><span style=\"font-size: 16px\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","id":"70493d8a-7d7f-4660-b1ed-c792d0d765be","lists":[{"text":"What You Will Do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What This Role Needs","content":"<li>At least 15 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Experienced in managing a huge team size</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closingExcellent in contract and commercial negotiation process</li><li>Experience in payment industry is a plus</li>"}],"text":"Head of Sales - Midtrans - #9618","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 18px;\">About The Role</span></b></div><div><span style=\"font-size: 16px;\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px;\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","descriptionBodyPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be","applyUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be/apply"},{"additionalPlain":"About The Team\nAs Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.\n\nOne of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing & executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.\n\nWe are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 14px\">As Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.</span></div><div><br></div><div><span style=\"font-size: 14px\">One of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing &amp; executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.</span></div><div><br></div><div><span style=\"font-size: 14px\">We are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Strategy","allLocations":["Jakarta"]},"createdAt":1708937527995,"descriptionPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","id":"7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","lists":[{"text":"What You Will Do","content":"<li>Design the overall end-to-end sales strategy which includes go-to-market (GTM) strategy and implied sales motions / incentives system</li><li>Define OKR &amp; building blocks for the entirety of nationwide sales team (Enterprise &amp; Small Medium Business teams) to ensure that company objectives are met - working closely with the product teams (including but not limited to GoFood, GoMart, GoCorp and GoPay)</li><li>Set sales targets in areas like product mix, sales volume, and market shares</li><li>Track OKR &amp; performance of the overall greater sales team (Enterprise, SMB Managed &amp; SMB Unmanaged teams) across all products</li><li>Oversee the execution of sales motions / building blocks: periodic review with working and/or leadership team, provide guidance to the overall sales strategy &amp; other relevant stakeholders</li><li>Establish a regular &amp; methodical planning rhythm to ensure that both sales team structure &amp; compensation plan are aligned to support reaching company targets. This would include merchant segmentation, sales structure review, sales earning optimization exercises, account mapping, territory planning; working together with the Head of Enterprise Sales and Head of SMB Sales</li><li>Become the bridge between Sales HQ &amp; on-the-ground merchant-facing teams to ensure seamless &amp; effective execution</li>"},{"text":"What This Role Needs","content":"<li>At least 10 years of relevant work experience in strategy, preferably within mid-to-senior management level from multinational company</li><li>Have strong analytical thinking and problem solving skills using various tools and methods</li><li>Comfortable working under pressure in a fast-paced and ambiguous environment</li><li>Ability to prioritize &amp; multitask across different initiatives (balancing breadth vs in-depth)</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Have great presentation skills - esp. the ability to present to senior management &amp; leadership</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>Fluent in Bahasa Indonesia &amp; English</li>"}],"text":"Head of Sales Strategy - #10056","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","descriptionBodyPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","applyUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721030934590,"descriptionPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","description":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","id":"9c0a73a5-09ce-4b06-8527-9415ef3d393c","lists":[{"text":"What You Will Do","content":"<li>Lead a team of IT Auditors in planning, preparation, coordination, and execution of audits to evaluate the adequacy and effectiveness of technology infrastructure, application, and process controls.</li><li>Provide clear, concise, and organized documentation of the audit processes and findings.</li><li>Identify and evaluate complex technology and business risks, implications, and related opportunities for improvements of internal controls.</li><li>Manage audit projects effectively – resource allocation, deliver on commitment, time management and quality reviews.</li><li>Serve as the Audit Committee Secretariat responsible for coordination of materials across the governance teams for periodic AC meetings.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Must have a minimum of 8-10 years of experience in technology audits, with at least 5 years in public accounting / advisory firms.&nbsp;&nbsp;</li><li>Must have strong practical experience in testing of GITC, application controls, ISO 27K, cybersecurity risk assessment, and ERP’s.&nbsp;</li><li>Must possess CISA certification at a minimum - additional certification in cyber, risk and technology governance preferred.&nbsp;</li><li>Knowledge and experience with OJK and Bank Indonesia (BI) technology audit requirements preferred.&nbsp;&nbsp;</li><li>Experienced with coaching and developing junior team members, strong confidence to interact with various stakeholders, excellent project management and organizational capabilities, ability to complete tasks and audit projects within tight deadlines.</li><li>Strong communication in English (verbally and in writing) and PowerPoint preparation skills.&nbsp;</li><li>Highly self-motivated, inquisitive (with a keen interest in learning new processes and technologies) and strive to continuously develop technically and professionally.</li>"}],"text":"Internal Audit Senior Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","descriptionBodyPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","hostedUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c","applyUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c/apply"},{"additionalPlain":"About The Team\n\nWe are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success\n\nWe're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>We are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success</div><div><br></div><div>We're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.</div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1721801286779,"descriptionPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","id":"ad8bd932-3494-4181-bd93-282665dce81d","lists":[{"text":"What You Will Do","content":"<li>Training Product Development: Develop and maintain detailed training materials, including manuals, user guides, and online resources, tailored to various audience levels. Collaborate with product managers, engineers, and other stakeholders to stay updated on product features and enhancements</li><li>Facilitation and Delivery: Conduct training sessions, both in-person and virtually, mainly for internal teams. Utilize a variety of instructional techniques and formats, such as role-playing, simulations, and interactive workshops</li><li>Assessment and Evaluation: Create and implement assessment tools to measure training effectiveness and knowledge retention. Gather feedback from trainees and use it to improve future training sessions</li><li>Support and Collaboration: Provide ongoing support and consultation to trainees post-training. Work closely with sales teams and internal stakeholders to address any training-related issues and ensure customer satisfaction to achieve business goals</li><li>Continuous Improvement: Stay current with the latest product developments and industry trends. Incorporate new training methodologies and technologies to enhance the learning experience.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or higher; majoring in Business, Economics, or relevant fields</li><li> 2 or 3 years of experience in a product training or related role within the tech industry. Has proven experience in developing and delivering training programs</li><li>Excellent presentation and communication skills</li><li>High attention to detail, has ability to explain complex technical concepts in a clear and accessible manner</li><li>Strong organizational and project management skills</li><li>Ability to adapt training methods to different learning styles and audiences</li><li>Ability to drive changes successfully and to keep people motivated in a highly changing environment&nbsp;</li><li>Proactive, ability to work in a team, and a strong can do attitude.</li>"}],"text":"Internal Trainer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d","applyUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d/apply"},{"additionalPlain":"Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Corporate Affairs","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1720685009263,"descriptionPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","description":"<div><span style=\"font-size: 11pt\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","id":"fc5f2c90-038e-4c53-9971-2ae72f680c03","lists":[{"text":"What you will do","content":"<li>Gojek Singapore communications:</li><div>Serve as the overall PR point of contact and develop communications strategies for the Singapore market, collaborating with the Gojek Singapore leadership team.</div><div>Develop and execute PR plans for Singapore-related announcements, handling all external-facing communications and materials.</div><div>Engage with Singapore media, manage media queries, and manage crisis and issues across media <a href=\"http://channels.Proactively\" class=\"postings-link\">ch</a>annels</div><div>Proactively seek thought leadership opportunities and lead OKR reporting for PR-related <a href=\"http://metrics.GoTo\" class=\"postings-link\">me</a>trics</div><div><br></div><li>GoTo Group communications support:</li><div>Support Group-level announcements and the development of associated English language communication materials</div><div>Maintain relationships with key international media contacts and handle media queries</div><div>Support issues management teams.</div><div>Develop thought leadership content, manage media opportunities and awards, and oversee a number of owned channels.</div><div><br></div>"},{"text":"What you will need","content":"<li>Excellent writing skills - proficiency with Chinese language media in Singapore is a bonus</li><li>Proven ability to build and maintain relationships with media contacts</li><li>Experience in pitching stories and managing media inquiries.</li><li>A cool head in a crisis</li><li>Meticulous approach to reviewing materials and ensuring accuracy</li><li>Ability to manage multiple projects without compromising quality.</li><li>Flexibility to manage unexpected challenges and opportunities</li><li>Enthusiasm for travel (regular travel to indonesia will be required) </li><div><br></div>"}],"text":"International & Singapore Communications Manager","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 11pt;\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt;\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","descriptionBodyPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03","applyUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03/apply"},{"additionalPlain":"About the Team\n\nThe IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721378203517,"descriptionPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","id":"4cb00240-117e-4ace-a959-fc567e447d5f","lists":[{"text":"What You Will Do","content":"<li>Manage multiple complex IT Finance initiatives</li><li>Ensure initiative deliveries are on time and adhere to IT Project Life-Cycle standards</li><li>Ensure information is delivered to the business through the correct channels, ensuring compliance with all controls and security requirements</li><li>Manage multiple internal stakeholders across countries and business units</li><li>Provide regular status updates to GoTo leaders and stakeholders</li>"},{"text":"What You Will Need","content":"<li>8+ years of work experience in IT project/program management in Finance Domain</li><li>Strong track record of leading successful IT projects/programs from start to finish&nbsp;</li><li>Ability to multi-task and effectively manage several projects in parallel</li><li>Ability to influence large, cross-functional teams</li><li>Strong interpersonal, facilitation, and leadership skills</li><li>Experience in managing Corporate Finance, Enterprise Data, and Enterprise business processes is highly desirable</li><li>Drive adherence to SDLC processes, drive to implement new processes and procedures applying industry knowledge and experience to cut costs, gain efficiencies, minimize risks, and reduce time to deploy, with attention towards automation and continuous improvement; make recommendations for process improvements; track and document all process improvements;&nbsp;</li><li>Good communication skills in English both oral and written</li>"}],"text":"IT Finance Project Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","descriptionBodyPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f","applyUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f/apply"},{"additionalPlain":"About the Team\n\nJoining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Joining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713930486899,"descriptionPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","id":"36caef5f-7a1c-4326-80b4-8c146060ac70","lists":[{"text":"What You Will Do","content":"<li>Develop and maintaining IT policies, standards and procedures according to applicable internal and external requirements, including the applicable regulations in Indonesia an other countries where GTF operate;</li><li>Develop and maintain compliance, governance and risk-related IT and business process flow;</li><li>Coordinating with compliance team to ensure that every initiative, development and collaboration are comply with the standards and regulations (internal and external);</li><li>Conduct routine evaluation of policies and procedures implementation and ensure best practice risk mitigation and assessment functions are maintained to comply with the company's strategy;</li><li>Coordinate with related IT work units to follow up on data requests and internal audit findings, external audits and regulators;</li><li>Develop the process and conduct the activities to safekeep or archive of every IT development document in a regular basis;</li><li>Implementing a good governance organization using the ISO27001, ISO 27701, PCI DSS framework and other relevant Technology &amp; Security best practices;</li><li>Develop and implement the RBAC and least privilege of access management in the GTF technology stack</li><li>Act as a Subject Matter Expert to the stakeholders and provide relevant &amp; applicable consultation for addressing the IT GRC requirement in lending product &amp; services.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years experiences as Information Security, IT Governance, Risk and Compliance (IT GRC) or IT Auditors;</li><li>Demonstrate excellent communication and writing skills and proficient with English written and spoken</li><li>Experienced in developing and maintaining IT and/or information security policies and procedures;</li><li>Excellent knowledge in developing risk management and IT framework, BIA, BCP and BCM Framework</li><li>Experienced in report document development and delivery;</li><li>Experienced in dealing with regulatory audit to represent the organization IT GRC operations;</li><li>Having good knowledge with local and regional payment &amp;&nbsp; lending regulatory requirements and how they impact IT policies (having experience is preferred);</li><li>Having excellent experience with ISO 27001, ITIL. COBIT, and PCI-DSS standards;</li><li>One or more of the following or equivalent certifications preferred: CISA, CRISC, ITIL, COBIT is preferred</li>"}],"text":"IT GRC Senior Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","descriptionBodyPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70","applyUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70/apply"},{"additionalPlain":"About The Team\n\nGoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.\n\nOur achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.\n\nAs a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design & Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.</div><div><br></div><div>Our achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.</div><div><br></div><div>As a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design &amp; Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720592684329,"descriptionPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","description":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","id":"da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of your Writer lead, and follow the predefined process that has been set by the team</li><li>Understand the product briefs and present ideas/solutions to the team under the supervision of your writer lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Proactively attend design reviews to gather feedback and provide critiques if needed</li><li>Proactively seek knowledge about UX</li><li>Participate in the end-to-end design process with peer researchers, designers, business, product and engineering teams. You will also get to engage with marketing and customer care unit to ensure the content is cohesive</li><li>Own your assigned streams and organize assigned tasks; which includes communicating updates and progress via the provided forums and channels. Be flexible to collaborate with other streams when needed</li>"},{"text":"What You Will Need","content":"<li>At least 1 year of experience in product writing for digital products or services</li><li>Strong understanding of writing fundamentals, critical/creative/structured thinking skills, grammar in both English &amp; Indonesian, and a familiarity of product design/ design thinking frameworks in order to further develop your writing output</li><li>Excellent communication and grammar skills in both English and Indonesian, both verbal and written, to effectively collaborate with stakeholders of varying seniority and backgrounds</li><li>A user-centric mindset in order to see things from their perspective, understand their concerns and feedback, and incorporate these insights into the work you produce</li><li>A drive to always find the root cause of an issue and validate your design - either through quantitative or qualitative research</li><li>A structured portfolio of written work that shows your ability and problem solving skills, a bonus if it demonstrates business impact and results</li><li>Ability to handle multiple tasks and prioritize work simultaneously</li><li>Demonstrate a detailed-oriented thought process with excellent documentation discipline</li>"}],"text":"Junior UX Writer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","descriptionBodyPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","applyUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d/apply"},{"additionalPlain":"About the Team\n\nTransport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.\n\nDespite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Transport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.</div><div><br></div><div>Despite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. </div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899257808,"descriptionPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","id":"f1d481f6-4e2d-401b-b310-fca641ab29d4","lists":[{"text":"What you'll do","content":"<li>Lead, mentor and recruit a team of highly talented and motivated engineers</li><li>Build and deploy features iteratively in production</li><li>Work cross-functionally with product, engineering and design teams across Gojek</li><li>Collaborate with internal teams to build and iterate on features</li><li>Build delightful user-facing experiences with smooth performance</li><li>Mentor and provide feedback to colleagues, participate in organisation building</li><li>Participate in research trips to better understand aspirations and pain points of our customers</li>"},{"text":"What you'll need","content":"<li>Should atleast have 6 years of relevant experience</li><li>Deep understanding of the iOS frameworks like UIKit, Foundation, etc.</li><li>Experience developing iOS apps in Swift</li><li>Attention to detail, particularly around software engineering fundamentals, testing methodologies, and quality</li><li>A strong customer focus</li>"}],"text":"Lead - iOS (Transport)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4","applyUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720610213311,"descriptionPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","description":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","id":"c9452ba2-cbb3-4ea5-83f7-79e765a67e58","lists":[{"text":"What You Will Do","content":"<li>As the Lead Auditor, you will support the design of risk-based audit plan influenced by regulatory compliance requirements, business needs and inputs from the governance teams (ERM, Ethics and Regulatory Compliance). You will deliver the audit as planned, discussion of issues with business and Group Audit, write up of report, advise and monitor on remediation progress. </li><div><br></div><div>Expectations of the role include: </div><div><br></div><li>Ability to deliver audit engagements independently and efficiently</li><li>Effective verbal and written communication (in Bahasa and English) of audit findings, remediation and reports to management.</li><li>Active participation and contribution to team discussion, audit planning, and stakeholder engagements.· &nbsp; </li><li>Ability to analyze operational process, regulatory issues and root cause.</li><li>Strong focus on quality deliverables such as audit report, work paper write ups, and presentation.</li>"},{"text":"What You Will Need","content":"<li>Mandatory: Minimum 8 years of audit experience obtained from public accounting and financial services internal audit roles.</li><li>Mandatory:&nbsp; Understanding and experience complying / auditing of relevant OJK regulations for multi-finance institutions.</li><li>Relevant certification in audit and risk preferred.</li><li>Highly motivated, demonstrated leadership attributes, meticulous attention to detail and problem solving</li><li>Effective communication in both Bahasa and English (verbal and written).</li><li>Ability to use data analysis tools (like ACL, MS Excel, Tableau, etc.).</li>"}],"text":"Lead Internal Auditor","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","descriptionBodyPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58","applyUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58/apply"},{"additionalPlain":"About The Team\nOur data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n","additional":"<div><b>About The Team</b></div><div>Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1719896801671,"descriptionPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","id":"4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","lists":[{"text":"What You Will Do","content":"<li>Manage data science infrastructure to streamline model development and deployment</li><li>Define and build scalable data pipelines that enables data scientists to build better models</li><li>Implement cutting edge big data frameworks to support batch and real-time jobs</li><li>Identify possible bottlenecks in the system and perform optimization</li><li>Build dashboards, models and deliver insights to support business analytics</li><li>Monitor and provide support to our infrastructure and production models</li><li>Mentoring team members through code review and knowledge sharing</li>"},{"text":"What You Will Need","content":"<li>At least 7 years of hands-on experience at large scales in data science / software engineering</li><li>Ability to write clean and structured SQL, Python and Shell programs</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Kubenetes, Docker, Infrastructure as Code, RDBMS and NoSQL Databases</li><li>Good understanding of machine learning techniques and algorithms</li><li>Good experience in serving real-time, production-level machine learning models</li><li>Management experience is preferred</li><li>Excellent communication skills</li>"}],"text":"Lead MLOps Engineer","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","descriptionBodyPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","applyUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0/apply"},{"additionalPlain":"About the Team\n\nThe GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.</div>","categories":{"commitment":"Permanent","department":"ODS - Transport & Mobility","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718255937171,"descriptionPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","id":"8bf17375-6318-400f-8216-4a132071777a","lists":[{"text":"What You Will Do","content":"<li>Roadmapping → Establish strategic objectives, roadmap and timelines to guide the development and enhancement of the GoCorp platform</li><li>Focus on optimizing the client experience, ensuring the platform meets and exceeds user needs and expectations. Execute with precision make sure products and features are launched in timely manner</li><li>Seek product ideas and feedback based on both quantitative and qualitative date, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that one size doesn’t fit all and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Work closely with business, sales, and marketing teams to align product strategies and objectives. Ensuring the all teams runs with the same drumbeat&nbsp;</li><li>Ensure seamless coordination with other product teams connected to the GoCorp platform to maintain a cohesive product ecosystem</li>"},{"text":"What You Will Need","content":"<li>Proven experience if min 5-6 years in product management, preferably within a tech or platform-based company and B2B product</li><li>Strong strategic thinking and planning skills with the ability to set and achieve the mid term and long-term objectives</li><li>Data oriented – demonstrated an ability to balance between quantitative and qualitative data to optimize client experience.</li><li>Exceptional problem-solving skills with a proactive approach to overcoming challenges</li><li>Excellent collaboration skills with experience working across multiple departments</li><li>Proficiency in managing the entire product lifecycle, from concept to launch and beyond</li><li>Strong communication skills to articulate product vision and objectives effectively to diverse stakeholders</li><li>Solid understanding of the technical aspects of platform development and integration.</li><li>Fluent in written and verbal english</li>"}],"text":"Lead Product Manager, GoCorp","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a","applyUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1716776042348,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"4a126665-42d6-4a36-82a5-089dca789f41","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Nurturing &amp; mentoring 5-7 engineers members</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize their ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 7-8+ years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Leadership experience in leading a distributed team of software engineers</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>Working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, xgboost, Keras</li><li>Prior experience with cloud provider (GCP is a plus)</li>"}],"text":"Lead Software Engineer - Data Science Platform","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41","applyUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719911495540,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","id":"a593bf17-baf2-479e-8154-c69d6a7d4f09","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost-effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems </li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure </li><li>Enhance code quality and product performance through continuous improvement and innovation </li><li>Collaborate and communicate effectively with teams across multiple geographies </li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves </li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices </li>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Erlang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with messaging protocol such MQTT &amp; prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Engineering Platforms","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09","applyUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. \n\nAt the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. </div><div><br></div><div>At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</div><div><br></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1711535878605,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","id":"3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems</li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure</li><li>Enhance code quality and product performance through continuous improvement and innovation</li><li>Collaborate and communicate effectively with teams across multiple geographies</li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves</li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in working with end to end Observability stack. Hands on experience in building and managing the telemetry pipeline at large scale</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with Grafana stack, Cortex, SLI/SLO platforms is a plus</li><li>Prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Observability","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","applyUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a/apply"},{"additionalPlain":"About the Team :\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</div><div><br></div><div>We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899083492,"descriptionPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","id":"9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences with minimal guidance for one of the world's fastest growing companies in travel</li><li>Understand, design and build to optimize in terms of resources used on the devices as well as simplify to meet the challenges of our always on-the-go users</li><li>Translate business requirements into scalable and extensible design</li><li>Partner with the product management team to define and execute the feature roadmap.Be responsible for defining and executing for complex, long term initiatives and help the team objectively lay out the roadmap and execute against smaller milestones</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Coordinate with cross functional teams (Backend, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence. Be the flag bearer for setting long term execution strategies and bring about the culture of operational excellence in the team</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in Android application development and product delivery</li><li>Predictability and balance of product delivery speed and quality</li><li>In depth knowledge of Android Apps architecture and implementation including proficiency in Kotlin, Architectural Components, Git, and Gradle</li><li>Understanding of TDD, Dependency Injection principles, Mobile Performance Tuning (Load time, Crash/ANR/Memory Leak tracking, Network optimisations)</li><li>Strong problem solving and analytical skills and a proven track record of being able to respond effectively to customer situations</li><li>A command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>A track record and passion for improving the code structure and architecture to improve testability and maintainability</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><div><br></div>"}],"text":"Lead Software Engineer - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","applyUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1704273923584,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","id":"2d3aae20-ff7e-4afb-8164-a351661c1680","lists":[{"text":"What You Will Do ","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest-growing company in the transportation industry&nbsp;</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Partner with the product management team to define and execute the feature roadmapCoordinate with cross-functional teams (Mobile, DevOps, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building the next generation of Gojek services</li>"},{"text":"What You Will Need ","content":"<li>Should have at least 6 years of hands-on experience in designing, developing, testing and deploying applications on Java or Go for large scale applications</li><li>Proficient in System Design, OOP, SQL, Linux/Unix, and Design Patterns. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities, through self-discovery or by vouching for exploratory tasks</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Lead Software Engineer (IC) - Go-Food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680","applyUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713944910535,"descriptionPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","id":"cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Proactively establish and strengthen relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia.</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals.</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors.</li><li>Project Leadership: Lead multiple projects in partnership with government institutions, focusing on Tech and the Digital Economy.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances.</li><li>Project Management: Oversee public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred.</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government.</li><li>Established network among government stakeholders with a proven impact on policy decisions.</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Manager of Food & Groceries Regulatory","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","applyUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719989851823,"descriptionPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","description":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","id":"ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","lists":[{"text":"What You Will Do","content":"<li>Maintain MI’s automation backend availability on Google Cloud Project&nbsp;</li><li>Continuously developing data pipeline architecture to ensure excellent performance&nbsp;</li><li>Do complex data analysis which are related to the Market Intelligence topics</li><li>Continuous knowledge update on latest tech capability to enhance the Market Intelligence deliverable in terms of depth, speed and variety of sources of references</li><li>Build and maintain a playbook for Market Intelligence data engineering projects</li>"},{"text":"What You Will Need","content":"<li>At least 2 years in <b>Data Engineer </b>roles</li><li>Talks in Python &amp; Linux</li><li>Exposure to data modelling would be preferred</li><li>Loves to experiment on the latest tech trends</li><li>Passionate in problem-solving and Root Cause Analysis (RCA)</li>"}],"text":"Market Intelligence (Data Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","applyUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4/apply"},{"additionalPlain":"Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.\n\nAs a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. \n","additional":"<div><span style=\"font-size: 9pt\">Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.</span></div><div><br></div><div><span style=\"font-size: 9pt\">As a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. </span></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720579532578,"descriptionPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","description":"<div><span style=\"font-size: 9pt\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","id":"967cfe0a-0243-4a2d-8813-038c355e43c3","lists":[{"text":"What you will do","content":"<li>Manage the marketing budget and ensure efficient allocation as well as prepare the report and regularly present it to senior management</li><li>Lead marketing metrics development, monitoring, and performance analysis periodically, as well as identify areas for <a href=\"http://improvement.Stay\">improvement.</a></li><li><a href=\"http://improvement.Stay\">Stay</a> updated on industry trends and the competitive landscape to inform strategic decision</li><li>Lead marketing campaigns development, monitoring, and evaluation incl. creative &amp; media strategy development &amp; execution with relevant stakeholders</li><li>Actively collaborate across functions &amp; streams especially product and strategy &amp; planning team in growing Transport business.</li><div><br></div>"},{"text":"What you will need","content":"<li>Bachelor's degree from a reputable university or equivalent practical experience</li><li>Min 4 years of experience working in a brand or product marketing field in FMCG, technology, telecommunication, or start-up</li><li>Excellent written &amp; verbal communication abilities at the business level with strong presentation skills to represent the Marketing team in functional meetings</li><li>Ability to work in a fast-paced, deadline-driven, and VUCA (volatile, uncertain, complex, and ambiguous) work environment</li><li>Strong capacity planning and reporting abilities; strong commercial sense and logical thinking skills to think outside the box as well as an understanding of budgeting, financial planning, and marketing <a href=\"http://metrics.Strong\">metrics.</a></li><li><a href=\"http://metrics.Strong\">Strong</a> analytical and quantitative skills; ability to use hard data and metrics to back up assumptions, and recommendations, and drive actions.&nbsp;</li><li>Familiarity with data analysis tools and software (SQL, Tableau, and Google Analytics)</li><div><br></div>"}],"text":"Marketing Planning Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","descriptionBodyPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3","applyUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3/apply"},{"additionalPlain":"About The Team\n\nOur Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media. \n\nAs a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media.&nbsp;</div><div><br></div><div>As a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!</div>","categories":{"commitment":"Internship","department":"HoldCo - Corporate Affairs","location":"Jakarta","team":"Media Intelligence","allLocations":["Jakarta"]},"createdAt":1719818000669,"descriptionPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","description":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","id":"a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","lists":[{"text":"What Will You Do","content":"<li>Monitor corporate news and other related information across channels (print, online, and social media).</li><li>Gather and analyze data from media monitoring to gain insights into public perception of the company and its performance.</li><li>Extract data and present interesting information from findings.</li><li>Identify trends and issues relevant to the company’s needs.</li><li>Collaborate to provide data-driven insights for other teams</li>"},{"text":"What Will You Need","content":"<li>Undergraduate students, preferably from Economics, Business, Computer Science, Marketing, Public Relations or Literature.</li><li>High proficiency in English and Bahasa Indonesia, both written and verbal.</li><li>A critical thinker, observant, and detail-oriented with vast knowledge of current issues and trends.</li><li>High willingness to learn.</li><li>Comfortable handling large data sets.</li><li>Knowledge in Ms Excel.</li><li>A collaborative team member as well as an independent self-starter.</li>"}],"text":"Media Intelligence Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","descriptionBodyPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","applyUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb/apply"},{"additionalPlain":"About The Team\n\nThe management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.\n\nThe AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.</div><div><br></div><div>The AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.</div>","categories":{"commitment":"Permanent","department":"FinTech - AML/CFT","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719311112001,"descriptionPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","description":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","id":"f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","lists":[{"text":"What You Will Do","content":"<li>As an official directly appointed by the relevant Director and responsible for the implementation of AML CFT in the company.</li><li>A pointed person for any Regulatory Compliance matters/projects as well as internal or external auditors in compliance reviews.</li><li>As an industry expert, keep track of the latest developments around regulations and find smart solutions to mitigate ML/TF risks</li><li>Remain knowledgeable of new or changing regulations, regulatory expectations, market conditions, and industry best practices and find smart solutions to mitigate ML/TF risks</li><li>Ensure Subject Matter Experts participate in all activities where expertise is required, including but not limited to, risk assessments, policy writing, training development, advice to the business, monitoring activities, and reporting</li><li>Provide senior management with actionable advice on how to effectively manage AML/CFT-related risks</li><li>Ensure all regulatory reporting requirements related to AML/CFT themes are met</li><li>Ensure implementation AML CFT regular trainings as well to Business Unit and Support Function and to liaise with the Learning &amp; Development PAC;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years in this role in the AML/CFT</li><li>You have extensive knowledge of the payments and or the banking/finance industry</li><li>A thorough understanding of AML/CFT laws and regulations incl. risks, controls, industry best practices and regulatory requirements</li><li>An excellent and direct communicator who talks straight without being rude</li><li>You have the ability to clearly explain AML CFT compliance and related risks, develop sound mitigation strategies, and find workable solutions&nbsp;</li><li>You have extensive experience representing and leading meetings with regulatory agencies, examiners and auditors</li><li>You have the ability to structure and prioritize in a high-volume, fast-paced environment and drive a process to completion</li><li>You are a team player that does not shy away from taking ownership</li>"}],"text":"Merchants AML/CFT Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","descriptionBodyPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","applyUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713245102772,"descriptionPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","description":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","id":"3f4f687f-8599-4d5c-96d5-8af234c3b09d","lists":[{"text":"What You Will Do","content":"<li>Identify and define business opportunities that aligns with the overall merchant services business objectives</li><li>Translate business opportunities into a fit problem statement and able to measure the priority of the problem&nbsp;</li><li>Collaborate with Product Team to develop a merchant focused product in onboarding and support&nbsp;</li><li>Develop Go-To Market plan and oversee the product adoption from funnel conversion rates and merchant experiences during the process.&nbsp;</li><li>Monitoring the product life cycle and continuously improved the product with a data driven decision making process</li><li>Engaged sales and ops team to deliver the best onboarding and support experience for merchants</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of working experience, experience in product and project management is a plus.&nbsp;</li><li>Possess a strong sense of agency in navigating and creating clarity in ambiguous situations.</li><li>Ability to break down complex problems, identify use cases and solutions, and thrive in unstructured environments.</li><li>Comprehensive understanding of data, design, research, and business processes, with the ability to effectively collaborate with diverse teams.</li><li>Strong analytical and quantitative skills, with the capability to utilize data and metrics to support requirements and features.</li><li>Effective communication skills to articulate strategy, insights, priorities, and plans coherently to all levels of management.</li><li>Meticulous attention to detail, with a commitment to upholding high standards and managing multiple, competing priorities concurrently with minimal supervision.</li>"}],"text":"Onboarding & Support Business Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","descriptionBodyPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d","applyUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"Lending Operations","allLocations":["Jakarta"]},"createdAt":1720692666755,"description":"","descriptionPlain":"","id":"0ae5053b-3c5f-432a-9b69-b4cdefb01b79","lists":[{"text":"What You Will Do","content":"<li>Master all Consumer Lending Operations-related data points, including Customer Service, KYC, Telesales, and Transactional Data.</li><li>Manage all Operations Dashboards and Reporting to ensure timely and accurate availability.</li><li>Provide analytical insights leading to actionable plans with positive impacts for stakeholders.</li><li>Support the Head of Operation and other stakeholders in executing operational experimentation and enhancing workflow automation processes.</li><li>Lead, mentor and develop Operation BI team member.</li><li>Assist Operation stakeholders in dealing with Fraud investigation, Campaign Setup, and regulatory reporting and audit preparation</li><li>Analyze, evaluate, and initiate improvements in day-to-day operations for efficiency, effectiveness, and scalability.</li><li>Develop job automation to build Datamart-level tables in Big Query for Operational Dashboard Reporting.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's Degree in Engineering, Mathematics, Statistics, or a related discipline is required.</li><li>5 years of experience in a fast-paced environment, with a background in project management and data analytics.</li><li>Possesses strong analytical, planning, and problem-solving skills.</li><li>Proficient in SQL and Advanced Excel, with a high level of competence in working with numerical data sets. Knowledge of Python and experience in automating tasks is highly advantageous.</li><li>Familiarity with at least one business intelligence tool such as Google Data Studio (Looker), Power BI, or Tableau is preferred.</li><li>Ability to work independently with excellent time management skills, collaborating effectively with cross-functional teams to drive initiatives aligned with organizational objectives and Key Results (OKRs).</li><li>Exceptional communication and interpersonal skills, capable of articulating complex ideas to non-technical stakeholders with clarity and precision.</li><li>Familiarity with data warehousing concepts and methodologies is considered a plus.</li>"},{"text":"About The Team","content":"<li>Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</li><li>Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly. In the coming year, in light of our new GoTo collaboration, we have exciting plans to scale up our team in effort to field the massive growth of our data pool.&nbsp;</li>"}],"text":"Operation Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79","applyUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79/apply"},{"additionalPlain":"Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy & Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs\n","additional":"<div><span style=\"font-size: 10pt\">Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs</span></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720522525041,"descriptionPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","description":"<div><span style=\"font-size: 10pt\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","id":"719f7a78-460a-4496-9298-ca57b835b120","lists":[{"text":"What you will do","content":"<li>Manage operational relationships with Fleet partners</li><li>Gain understanding of the mechanics of Fleet management, and identify pain points</li><li>Provide first level support for Fleet partners to ensure their business can thrive sustainably</li><li>Enhance the dynamic relationships among Gojek, Driver Partners, and Fleet Partners</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 3 years work experience in relevant sectors, e.g. Operations, Process Improvement and Management</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in English and in Bahasa Indonesia</li><li>Strong sense of business and tech processes</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Operation Support Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","descriptionBodyPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120","applyUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120/apply"},{"additionalPlain":"About The Team\n\nThe Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful experience.The Trust & Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and stakeholders.If you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust & Safety team.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful </span><a href=\"http://experience.The\" style=\"font-size: 10pt\" class=\"postings-link\">experience.The</a><span style=\"font-size: 10pt\"> Trust &amp; Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and </span><a href=\"http://stakeholders.If\" style=\"font-size: 10pt\" class=\"postings-link\">stakeholders.If</a><span style=\"font-size: 10pt\"> you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust &amp; Safety team.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1708072107075,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","description":"<div><span style=\"font-size: 16px\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","id":"6f3368c9-6e84-489c-add3-4ad1fd4b9519","lists":[{"text":"What You Will Do","content":"<li>Provide regular analysis and reports on operational performance including compliance, escalations, quality, risk, and KPI tracking to guide decision-making and devise proactive solutions</li><li>Collaborate with cross-functional teams to build, automate, and improve on the availability, integrity, accuracy, and reliability of reporting, data logging, and data pipelines to be secure and compliant</li><li>Liaise with internal and external stakeholders for regulatory and compliance reports whenever needed, including issue investigation and report verification</li><li>Create and maintain performance management dashboards, visualizations, and trackers for Operations</li><li>Develop data-driven business insights and work with cross-functional teams to identify opportunities and implement new product features or system enhancements related to Trust &amp; Safety</li><li>Identify operational weaknesses and opportunities to help improve or innovate new processes and projects to drive user and vehicle quality, customer experience, and compliance to regulatory requirements</li><li>Prepare regulatory compliance reports to ensure adherence to relevant data protection, Insurance, earnings and safety regulations</li><li>Implement and maintain a good data management system to ensure the integrity, confidentiality, and availability of trust and safety-related data.</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in analytics and operations/compliance-related role</li><li>A wizard at working on and analyzing large datasets, with the ability to translate quantitative findings into action plan, demonstrated through understanding of&nbsp; statistical methods and modeling techniques.</li><li>Strong stakeholder and project management capabilities, with great attention to detail</li><li>Resilience and ability to take initiative in our constantly-changing fast-paced environment</li><li>Strong knowledge of SQL, Python, Google Suite, and MS Excel (advanced) is required</li><li>Experience in BI tools such as Tableau, Metabase, or Data Studio is a plus</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Operations Analyst, Data Operations (Trust & Safety)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519","applyUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><span style=\"font-size: 10pt\"><b>About the team </b></span></div><div><br></div><div><span style=\"font-size: 10pt\">At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</span></div>","categories":{"department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721275390563,"descriptionPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","description":"<div><span style=\"font-size: 10pt\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","id":"03e3c5dd-2c14-4737-820e-f32b6cccf632","lists":[{"text":"What you will do:","content":"<li>Monitor and analyze key performance indicators (KPIs) to drive continuous improvement in operations.</li><li>Build and maintain strong relationships with merchant partners, promptly addressing their needs and concerns.</li><li>Train, mentor, and manage a team of onboarding specialists to ensure high performance and professional development.</li><li>Collaborate with internal teams to ensure drivers, merchants, and customers receive exceptional service.</li><li>Stay updated with industry trends and competitor activities to keep GoMart ahead.</li><li>Identify opportunities for operational efficiencies and implement best practices across the team.</li><li>Prepare routine reports and present findings as the basis of rationale and recommendations for strategic decision-making</li><li>Develop and implement strategies to enhance the onboarding process and improve merchant satisfaction.</li>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Strong analytical thinking, insights generating, and complex problem-solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds and ability to manage small team&nbsp;</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written English</li>"}],"text":"Operations Manager - GoMart","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt;\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","descriptionBodyPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","hostedUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632","applyUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632/apply"},{"additionalPlain":"About the team \n\nThe Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721103093996,"descriptionPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","id":"90d1d8b9-75fb-4211-8d69-99412932f5ba","lists":[{"text":"What you will do","content":"<li>Work closely with business and support units to design and execute GoTo Financial payments advocacy.</li><li>Lead external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders to advance GoTo Financial’s mission to provide accessible and safe payment products to all Indonesian users.&nbsp;</li><li>Support Compliance and Regulatory Affairs matters in GoTo Financial&nbsp; Payments Compliance operations, which includes but is not limited to business/product reporting and approval process with the regulators, and technical regulatory assessment</li><li>Create and maintain the latest update of payments regulations databases and provide/disseminate assessment on such regulations to the internal units in GoTo Financial</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law/ Economics/Management/ Accounting and International Relations. Having a master’s degree would be an advantage.</li><li>At least 4 years of mixed experience in the area of public policy/public affairs, and/or regulatory compliance and past working experience in Bank Indonesia/ Otoritas Jasa Keuangan and Public Affairs consulting firms will be an advantage.&nbsp;</li><li>Advanced level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks and proactively choose the best solutions and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including building credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"Payments Compliance PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba","applyUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba/apply"},{"additionalPlain":"\n","additional":"<div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - People & Culture","location":"Jakarta","team":"HR Information Systems","allLocations":["Jakarta","Singapore"]},"createdAt":1718958420176,"descriptionPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","description":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","id":"8fe35112-8410-4cf3-9a50-4c7287e95b57","lists":[{"text":"What You Will Do","content":"<li><b>HRIS Management &amp; Operations: </b>Operate and administer end-to-end Workday as our HRIS platform, serve as technical lead for Workday Core HCM, Talent Management, Absence, and Compensation. Provide technical support on day-to-day HR processes such as operations, payroll, performance management, and merit cycle. Act as a subject matter expert on HRIS-related inquiries and troubleshoot any technical issues that arise.</li><li><b>Process Improvement: </b>Identify opportunities to streamline HR processes using HRIS, automate manual efforts, and increase overall efficiency. Partner with cross-functional teams to identify opportunities for improvement, gather requirements, design, recommend, and implement system-driven solutions.</li><li><b>System Implementation &amp; Integration: </b>Collaborate with partners (HR and IT team) to configure and optimize HRIS modules, workflows, and integrate with other systems such as Payroll, ATS, and Finance to create seamless data flows. Lead HRIS system update and implementation of new HRIS modules, working with vendors and internal teams to plan and execute the process smoothly and successful adoption by stakeholders.</li><li><b>Report Development: </b>Develop and maintain custom reports, dashboards, and visualizations within HRIS to provide insightful HR metrics and analytics to stakeholders.</li><li><b>User Access Management and Compliance: </b>Manage user access and permissions to ensure data security and privacy compliance. Ensure HRIS compliance with relevant data protection and privacy regulations. Monitor and audit HR data to maintain accuracy, quality, and integrity, implementing necessary corrections and preventive solutions.</li><li><b>Training: </b>Provide training to HR staff and end-users on using and familiarities with the HRIS in respective to their roles.</li>"},{"text":"What You Will Need","content":"<li>Proven experience (typically 5+ years) in HRIS management and optimization.</li><li>Strong proficiency with Workday and related HR systems (Lever, Degreed, Larona, etc).Strong understanding of HR processes and workflows, with the ability to translate business requirements into HRIS solutions.</li><li>Excellent project management and problem solving skills, capable of handling multiple initiatives in a fast-paced environment.</li><li>Strong influencing skills with the ability to communicate clearly and confidently with stakeholders.</li><li>Strong managerial and leadership skills with the ability to guide, develop, and mentor team members to make things happen.</li><li>Experience communicating effectively across teams in markets across the region.</li><li><b>Preferred Qualifications: </b>Certification in Workday in one of the following modules: Core HCM, Advanced Compensation, Reporting, Talent, Performance, or Absence Management. Experience in SaaS HR system configuration. Experience with downstream system integrations such as Google Workspace, Google Cloud Platform, Workato, and JIRA/Asana.</li>"}],"text":"People Systems Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","descriptionBodyPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57","applyUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57/apply"},{"additionalPlain":"About The Team\n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div><br></div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721379671434,"descriptionPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","description":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","id":"49388333-1938-4c06-b453-911eee08c53f","lists":[{"text":"What You Will Do","content":"<li>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. </li><li>Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis</li><li>Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</li><li>Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li>"},{"text":"What You Will Need","content":"<li>At least 3 years working experience in an analytical role&nbsp;</li><li>Proficiency in multiple analytic tolls with strong knowledge of SQL and experimentation process</li><li>Effective communication skills with the ability to present financial information clearly and concisely</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Strong business acumen with a data-driven approach to problem-solving and the ability to drive initiatives independently.&nbsp;</li><li>A confident communicator in verbal and written English</li>"}],"text":"Pricing & Supply Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","descriptionBodyPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f","applyUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f/apply"},{"additionalPlain":"Our GoFood Strategy & Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. \n\nThe gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably. \n\nWhen our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">Our GoFood Strategy &amp; Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">The gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">When our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721383021327,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","description":"<div><span style=\"font-size: 9pt\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","id":"0911a6fe-475a-498f-bf48-7d492e3d04d2","lists":[{"text":"What You Will Do","content":"<li><b>Strategize, experiment, and optimize: </b>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact <a href=\"http://analysis.Execute\">analysis.</a></li><li><b><a href=\"http://analysis.Execute\">Execute</a> and collaborate: Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</b></li><li><b>Explore:</b> Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li><div><br></div>"},{"text":"What You Will Need","content":"<li>BS/MS in Business, Engineering, Computer Science, Mathematics, Economics, Statistics, or equivalent experience</li><li>At least 4 years of working experience in an analytical role</li><li>Scientist thinking process that can work in increments and exponents, coupled with hypothesis-driven mindset</li><li>Proficiency in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with strong knowledge of SQL and experimentation process</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><div><br></div>"}],"text":"Pricing & Supply Senior Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2","applyUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2/apply"},{"additionalPlain":"Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714372709159,"descriptionPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","description":"<div><span style=\"font-size: 10pt\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","id":"44117b68-3ece-40ac-91c1-920caadfe5dd","lists":[{"text":"What You Will Do","content":"<li>Design and construct scalable streaming or batch data pipelines to meet various business requirements.</li><li>Establish reliable monitoring and alerting systems to assess data pipeline performance.</li><li>Identify potential bottlenecks in the system and optimize as needed.</li><li>Manage the data science infrastructure to streamline model development and deployment.</li><li>Mentor team members by conducting code reviews and sharing knowledge.</li>"},{"text":"What You Will Need","content":"<li>Experience with streaming processing and Change Data Capture (CDC) tools such as Debezium, Flink, Kafka, etc. is necessary.</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Docker, RDBMS, and NoSQL Databases is desirable.</li><li>Proficiency in Python and SQL is expected.</li><li>Must be self-driven, with a strong sense of ownership, and capable of working independently to solve problems and develop solutions.</li><li>Project management skills to successfully drive large-scale projects from initiation to completion are needed.</li><li>Excellent communication skills, including proficiency in English, are required.</li><li>Understanding of machine learning techniques and algorithms is advantageous.</li>"}],"text":"Principal Data Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","descriptionBodyPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","hostedUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd","applyUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd/apply"},{"additionalPlain":"About the Team - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","additional":"<div><b style=\"font-size: 10pt\">About the Team</b><span style=\"font-size: 10pt\"> - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721188007441,"descriptionPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","description":"<div><span style=\"font-size: 10pt\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","id":"0197001e-f39c-4d55-b6b9-1cf247bd17b0","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutions, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li>At least 8 years of relevant experience</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Principal Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","descriptionBodyPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0","applyUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive. \n\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and </span><a href=\"http://automations.You\" class=\"postings-link\"><span style=\"font-size: 16px\">automations.You</span></a><span style=\"font-size: 16px\"> are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.&nbsp;</span></div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Gurugram"]},"createdAt":1721890257186,"descriptionPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","id":"6f2d563a-182c-4c23-8c72-9d2a4f563ed9","lists":[{"text":"What You Will Do","content":"<li>Improves code structure and architecture in service of testability and maintainability</li><li>Has in-depth understanding of multiple programming languages/paradigms, and highly proficient in one technology area, including how it interacts with the system</li><li>Leads new language/framework POC within a technical focus area, participates in the design review process, and providing constructive criticism for improvement</li><li>Is accountable for the operationalization of the tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Is accountable for ensuring that their squad has strong sets of documentations and journals of how their design and architecture evolves over time</li><li>Ensures predictability, quality &amp; throughput of their squad's delivery</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad's deliveryPrioritizes work based on understanding the trade-off between quality, tech-debt, and delivery</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: significant experience in one or many of the areas including golang/python programming, Events/stream processing framework development, engineering tooling and user facing interfaces, Kubernetes administration</li><div><br></div>"}],"text":"Principal Engineer - Cloud Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px;\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9","applyUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9/apply"},{"additionalPlain":"About the Team :\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div><span style=\"font-size: 11pt\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721116359853,"descriptionPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","id":"7c3c43e3-8b8d-48a4-a590-7754207b2d1b","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, reliable and fault tolerant platforms for one of the world's fastest growing unicorns</li><li>You will be responsible for the overall delivery and the solution architecture of the offerings your team will be working on</li><li>You will own prioritization of initiatives to maximize achievements on objectives and growth for engineering at GoTo</li><li>You should understand product engineering and have empathy with problems and pain points of Product Engineers. &amp; you will continuously contribute to make their experience better</li><li>You shall write code because you like to. You never stop wanting to get better at it</li><li>Communicate, collaborate and work effectively with product teams distributed in a global environment</li><li>You will be responsible for the overall growth, learning and happiness of your team</li><li>Is independently responsible for coaching, development, and career management for the team</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have experience in leading a team of 6-8 engineers and owning the overall delivery for the teams</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Have experience with recruitments and staffing management to help in building a sustainable team</li><li>Can take recruitment and staffing responsibilities depending to balance out the growth</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: Significant experience in one or many of the areas including Clojure programming, Stream processing framework development, engineering tooling and user facing interfaces</li>"}],"text":"Principal Software Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt;\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b","applyUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b/apply"},{"additionalPlain":"About the Team\n\nOur Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1715060912791,"descriptionPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"426f18b4-739e-4da0-a74b-446c349c0a31","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Collaborate with cross functional teams (Mobile, DevOps, UX, QA etc.) on execution and delivery</li><li>Partner with the team to define and execute the feature roadmap</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"What You Will Need","content":"<li>Should have at least 7 years of hands-on experience in designing, developing, testing and deploying applications at scale</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Principal Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31","applyUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719211012411,"description":"","descriptionPlain":"","id":"fc7c3413-6c4f-42bd-a048-70387bd490a4","lists":[{"text":"What you will do:","content":"<li>Process Analysis and Assessment: 1. Conduct comprehensive assessments of existing business processes to identify inefficiencies, bottlenecks, and areas for improvement. 2. Gather and analyze data to understand process performance and identify root causes of issues. 3. Develop process maps, flowcharts, and other documentation to visualize current state processes.</li><li>Improvement Strategy Development: Collaborate with stakeholders to design and develop strategies for process improvement, focusing on enhancing efficiency, quality, and customer satisfaction.</li><li>Implementation of Improvements: 1. Lead cross-functional teams in the implementation of process improvements, ensuring alignment with business goals and objectives. 2. Develop &amp; monitor detailed project plans, timelines, and milestones to guide improvement initiatives.</li><li>Change Management and Communication: Drive change management efforts &amp; communicate effectively to ensure smooth adoption of new processes and practices.</li><li>Performance Monitoring and Reporting: 1. Establish key performance indicators (KPIs) to measure the effectiveness of process improvements. 2. Conduct post-implementation reviews to assess the impact of changes and identify further improvement opportunities.</li><li>Continuous Improvement Culture: Provide mentorship and guidance to stakeholders on process improvement methodologies and tools.</li>"},{"text":"What you will need:","content":"<li>Bachelor's degree in Business Administration, Industrial Engineering, Operations Management, or a related field. A Master's degree is preferred.</li><li>Proven experience in business process improvement, process engineering, or related <a href=\"http://roles.Strong\" class=\"postings-link\">roles.</a></li><li>Strong knowledge of process improvement methodologies (e.g., Lean, Six Sigma, Kaizen).</li><li>Excellent analytical and problem-solving skills.</li><li>Exceptional project management skills, with experience leading cross-functional teams.</li><li>Strong communication and interpersonal skills, with the ability to influence and drive change.</li><li>Proficiency in process mapping and analysis tools (e.g., Visio, Lucidchart).</li><li>Ability to manage multiple projects and priorities in a fast-paced environment.</li>"},{"text":"Preferred Skills:","content":"<li>Fluent in English&nbsp;</li><li>Experience with data analysis tools (e.g., Excel, Tableau, Power BI).</li><li>Knowledge of change management principles and practices.</li><li>Familiarity with ERP and CRM systems, especially Salesforce</li><li>Experience in training and development related to process improvement.</li>"}],"text":"Process Improvement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4","applyUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4/apply"},{"additionalPlain":"About The Team\n\nGoTo Procurement  Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.\n\nAs a team, we are not only concerned about the company but also the professional and personal growth & aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">GoTo Procurement&nbsp; Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we are not only concerned about the company but also the professional and personal growth &amp; aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things</span></div>","categories":{"department":"HoldCo - Finance","location":"Jakarta","team":"Procurement","allLocations":["Jakarta"]},"createdAt":1721729730710,"descriptionPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","id":"c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","lists":[{"text":"What Will You Do","content":"<li>Lead and execute the Vendor Selection process to ensure that the company is getting what it really needs as well as the best deal in the market, following GoTo Procurement Procedure while adhering to relevant Policies and Procedures within the organization and collaborating with the relevant stakeholders and Subject Matter Expert (SME) to support comprehensive evaluation. The vendor selection process will be for both Tactical and Strategic bidding and aim for cost optimization targets and ensure the proper documentation to establish transparency and accountability</li><li>Drive cost optimization initiatives to support organization operating cost optimization through the execution of Procurement activities, including mitigation of any relevant risks within the Source-to-Pay process and supply chain.&nbsp;</li><li>Owning the Source-to-Pay process by ensuring a seamless transition throughout the steps, starting from capturing business needs up to Vendor Payment</li><li>Increase Procurement’s technology and platform utilization and target for SLA optimization and Sourcing Quality</li><li>Develop a Sourcing competencies framework as part of people development within the Procurement Sourcing organization</li><li>Build the right vendor market and network as well as internal stakeholders, to support the collaborations within Procurement processes</li><li>Lead and collaborate Vendor Value Creation Program together with Critical/Valued vendors to deliver innovation, better speed to market, productivity, asset utilization, sustainability, etc.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Bachelors of business, supply chain management, or any other related field. Preferably has been working in Procurement too</li><li>At least 2 years in procurement areas, preferably from multinational companies</li><li>Strong business and commercial mindset</li><li>Excellent negotiation, organizational, and collaboration skills</li><li>Excellent interpersonal and communication skills</li><li>Excellent project management skills</li><li>Advanced in verbal and written English proficiency</li>"}],"text":"Procurement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","descriptionBodyPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","applyUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274/apply"},{"additionalPlain":"About the Team\n\nThe Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.\n\nWe have helped simplify payments for over 750,000 merchant partners, over  1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.</div><div><br></div><div>We have helped simplify payments for over 750,000 merchant partners, over&nbsp; 1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1720599307040,"descriptionPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","description":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","id":"83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","lists":[{"text":"What You Will Do","content":"<li>Conduct merchant research and analyze user data to identify trends and pain points.</li><li>Working with Business Intelligence teams, writing queries and learning to set up product metric tracking dashboards&nbsp;</li><li>Help summarize merchant interviews as insights</li><li>Collaborate with product managers and designers to define product requirements.</li><li>Develop and present product recommendations based on data analysis.</li><li>Assist with creating product prototypes and user testing.</li><li>Stay up-to-date on industry trends and competitor analysis.</li>"},{"text":"What You Will Need","content":"<li>Strong analytical skills with proficiency in data analysis tools, candidates with experience will be preferred</li><li>The ability to write SQL queries is strongly preferred</li><li>Excellent communication and presentation skills.</li><li>A passion for product development and a keen eye for detail.</li><li>Familiarity with the Indonesian payments landscape is a plus.</li>"}],"text":"Product Analyst Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","descriptionBodyPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","applyUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8/apply"},{"additionalPlain":"About The Team\n\nThis vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.  \n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>This vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.&nbsp;&nbsp;</div><div><br></div>","categories":{"department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1718084687109,"descriptionPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","description":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","id":"a1ebb8d4-0af0-4707-9efb-8f52aa781c44","lists":[{"text":"What You Will Do","content":"<li>Help define the roadmap, goals, and vision for the product experience</li><li>Work with design leads, product heads, marketing and engineers to build/improve user experience and ways of working towards that vision</li><li>Manage projects, solve complex problems, and enable your team to deliver delightful solutions that drive impact</li><li>Build systems for design documentation &amp; help establish processes to ensure seamless collaboration</li><li>Mentor and coach a team of designers, improve stakeholders grasp and application of design thinking</li><li>And most importantly, make sure your team is engaged well and building things that make them successful</li>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in product design, but still willing to learn more about product research</li><li>Proficiency in all areas of digital product design; visual design, user experience design, user research prototyping, advocacy and building showcases. Additional exposure to motion, sound, video and other craft are welcome</li><li>Ability to draw insights from both qualitative &amp; quantitative data, and further identify problem areas to work on.</li><li>Ability to design, advocate and prioritize user research with our research team</li><li>Knowledge in design fundamentals, such as design thinking frameworks, HCI principles, and being able to take on a structured approach in solving problems</li><li>Excellent organizational, project management, and collaboration skills to manage a wide range of stakeholders</li>"},{"text":"","content":"<li><br></li>"}],"text":"Product Design Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44","applyUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44/apply"},{"additionalPlain":"About the Team\n\nThe Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. \n\nWe’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers. \n\nThe Loyalty, Incentives & Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more. \n\nWe are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .\n\n\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. </div><div><br></div><div>We’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers.&nbsp;</div><div><br></div><div>The Loyalty, Incentives &amp; Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more.&nbsp;</div><div><br></div><div>We are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .</div><div><br></div><div><br></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718798053606,"descriptionPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","id":"e407433b-435a-4607-89bd-5faf51cf622e","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of a senior product designer, and follow the predefined process set forth by the team</li><li>Able to comprehend the product briefs and be able to present the ideas/solutions to the team under the supervision of the product design lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Define end-to-end wireframe and wireflow for features using standard wireframing tools</li><li>Document the design process for each feature, such as research findings, ideations, usability tests, release, and monitor the impact after the product release</li><li>Contribute to the team cadence discussion and make occasional short presentations to the team, as well as present team’s updates if needed</li><li>Proactively seek/give feedback from other stakeholders to make sure concepts are meeting the intended project goal</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of relevant experience in the product design industry</li><li>Familiar with data and can identify problem areas, further map out the user journey, and break the problems into smaller chunks</li><li>Use basic analytics tools to gather customer data (funnel)&nbsp;</li><li>Possess a good knowledge of design fundamentals, such as design thinking framework and other frameworks to develop products</li><li>Able to sketch the ideas into wireframes, learn how to make wireflow, and do wireframing for well-defined features</li><li>Good knowledge of the tools, such as Overflow, Miro, Sketch, Figma, or similar ones that are widely used by Product Designers</li><li>Knowledge of design validation, either through quantitative or qualitative research</li><li>Preferably some knowledge of service design and experience with working on mobile app design</li>"}],"text":"Product Designer - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e","applyUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e/apply"},{"additionalPlain":"About The Team\n\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718166115141,"descriptionPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","description":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","id":"b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirements and the impact of each feature, as well as the go-to-market strategy to ensure adoption of the features</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in product management experience</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Growth","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","applyUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba/apply"},{"additionalPlain":"About The Team\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. \n\nThe Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.\n","additional":"<div><b>About The Team</b></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology.&nbsp;</div><div><br></div><div>The Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.</div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719305116114,"descriptionPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","id":"6f05ee4a-fa49-4aca-8990-c6607cd7cf09","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched&nbsp;</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirement and the impact of each feature as well as the go to market strategy to ensure adoption of the features.&nbsp;</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of total experience, with 2-3 years experience specifically in product management</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09","applyUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09/apply"},{"additionalPlain":"About The Team\nWork hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Work hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721026583842,"descriptionPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","id":"92f4b266-849a-42f2-b7e0-859360a003d8","lists":[{"text":"What You Will Do","content":"<li>Develop and own end-to-end project and program plans that outline scope, goals, deliverables, required resources, and timelines&nbsp;</li><li>Monitor progress of projects and programs to highlight plan deviations,, resolve issues and propose corrective actions to remove implementation blockers</li><li>Oversee and synergise multiple projects to ensure prompt completion within scope, and within budget</li><li>Work closely with internal and external stakeholders from cross-functional teams to assess feasibility of initiatives, develop the scope, and deliverables</li><li>Act as a point of escalation for project and program initiatives’ issues, mediate issues, and ensure stakeholder’s expectations are met</li>"},{"text":"What This Role Needs","content":"<li>At least 3 years of work experience in the financial industry, having worked in mid to large-scale cross-functional projects and/or programs, particularly in lending (consumer and/or loan lending products, such as cash loan, buy now pay later, merchant financing, vehicle financing, etc)</li><li>Well-versed in speaking &amp; writing in English, Bahasa Indonesia; Mandarin is a plus</li><li>Comfortable in fronting conversations with senior leaders and C-suite leaders</li><li>Able to work under pressure with strict implementation timelines</li><li>Possess a strong ability to analyze data and generate insights to value-add to the projects/programs</li><div><b>Soft Skills</b></div><li>Stakeholder management skills</li><li>Sharp business acumen</li><li>Attention to details</li><li>Time management</li><div><b>Hard Skills</b></div><li>Project / ProgramManagement Skills, ideally CAPM certified will be advantageous</li><li>Six Sigma Skills, ideally Six Sigma GreenBeltcertified will be advantageous</li><li>Knowledgeable about financial industry laws &amp; regulations &amp; being compliant at all times</li><li>Good working knowledge of Project Management tools like Jira, Lark and Google Suites</li><li>Knowledge about e-commerce / transport industries is a plus</li>"}],"text":"Program Manager, Consumer Lending - #10310","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","descriptionBodyPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8","applyUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8/apply"},{"additionalPlain":"About the Team\n\nOur Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720752364065,"descriptionPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","id":"20554643-fae8-4082-8797-7d5fd44db8b0","lists":[{"text":"What You Will Do","content":"<li>Develop and run complex analysist to support business decision</li><li>Design and develop dashboards to track business and product performance</li><li>Leverage data from dashboards as well as other sources to derive insights as a basis of rationale and recommendations in decision-making processes</li><li>Running a project management for multiple projects at different stages &amp; complexity</li>"},{"text":"What You Will Need","content":"<li>At least 2-3 years of experience in a business analytics or business intelligence role at a tech company</li><li>End-to-end the problem-solving mindset</li><li>Strong communication and project management skills</li><li>Strong proficiency in SQL, Microsoft Excel, and PowerPoint</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"Project Manager - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0","applyUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0/apply"},{"additionalPlain":"About the Team\n\nInsurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721362323598,"descriptionPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","id":"8906c3d0-c77f-4a0a-8f25-8b738515ede3","lists":[{"text":"What You Will Do","content":"<li>Attend daily standup meetings, sprint planning, and backlog reviews</li><li>Communicate project status to internal and external teams promptly</li><li>Analyze and estimate product features from a testing perspective</li><li>Ensure software quality by adopting best practices in software development</li><li>Design, develop, and execute automation scripts using open-source tools</li><li>Identify, record, document, and track bugs thoroughly</li><li>Perform thorough regression testing when bugs are resolved</li><li>Collaborate with product managers to clarify feature requirements and ensure comprehensive test coverage</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of experience in professional testing</li><li>Strong understanding of unit testing concepts and problem-solving using online resources</li><li>Deep knowledge of Manual &amp; Automation test methodologies and principles</li><li>Capability to create testing scenarios/scripts using test management tools</li><li>Experience in Mobile and API Testing in both manual &amp; automation contexts</li><li>Proficiency with automation tools like Jira, Selenium, RestAssured, ​​TestNg using Java (preferably), Postman, Gitlab, Kafka</li><li>Good understanding of logging mechanisms, messaging services, and pipelines</li><li>Experience working with the AGILE process methodology and strong interpersonal communication skills for collaboration with remote teams</li>"}],"text":"QA Engineer - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3","applyUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717052781419,"descriptionPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","description":"<div><span style=\"font-size: 10.5pt\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","id":"4ba1eea8-feed-4843-be2e-93a21f0eadb1","lists":[{"text":"What Will You Do","content":"<li>Perform exploratory data analysis using SQL and present interesting findings to business stakeholders to drive business and strategic decisions</li><li>Design and analyze experiments to improve service quality and quantity</li><li>Build and maintain self-serve data products such as dashboards (Looker &amp; Tableau) and tables to reduce time to insights</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Should have at least 2-3 years of practical experience in <a href=\"http://SQL.Prior\" class=\"postings-link\">SQL.</a></li><li><a href=\"http://SQL.Prior\" class=\"postings-link\">Prior</a> experience with applied statistics, experimental design is a <a href=\"http://plus.Able\" class=\"postings-link\">plus.</a></li><li><a href=\"http://plus.Able\" class=\"postings-link\">Able</a> to tell a coherent data narrative using visualization tools and able to set best practices in data visualization to convey a product insight through impactful <a href=\"http://graphs.Proven\" class=\"postings-link\">graphs.</a></li><li><a href=\"http://graphs.Proven\" class=\"postings-link\">Proven</a> ability to recognize business needs and ability to communicate with multiple stakeholders including PMs, business and <a href=\"http://operations.Balance\" class=\"postings-link\">operations.</a></li><li><a href=\"http://operations.Balance\" class=\"postings-link\">Balance</a> attention to detail with swift execution.</li><div><br></div>"}],"text":"Region Analytics Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","descriptionBodyPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1","applyUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1/apply"},{"additionalPlain":"About The Team\n\nAs an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">As an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713428751727,"descriptionPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","description":"<div><b style=\"font-size: 10pt\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","id":"0489939a-c571-4d5f-adaa-95ceac8912c5","lists":[{"text":"What You Will Do: ","content":"<li>Responsible for completed orders and profit and loss target achievement</li><li>Provide analytics to support operations team such as Supply Reliability, Fraud rules, Driver’s Engagement etc. at the regional level</li><li>Deploy defined strategies from operations perspective during the process of establishing the new area of service as well as optimizing existing area</li><li>Ensure SOP and legal compliances in the region</li><li>Support Regional Operation Head to oversee all districts and branches operations</li><li>Analyze driver states &amp; measure efficiency of various driver badges to generate more high quality drivers in the region</li><li>Support Regional Operation Head in product changes roll out in the region</li>"},{"text":"What You Will Need:","content":"<li>Having at least 5 years experience in supply chain, preferably at the managerial level and from Multi National Company or similar experience in the Ride Hailing/ On Demand Service Industry</li><li>Strong analytical thinking and problem solving skills using various improvement tools and methods (preferably have prior exposure to SQL)</li><li>Having good understanding about supply and demand planning</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Lead team / project as well as persuade stakeholders to ensure speed &amp; quality of project / initiative</li><li>Proficiency in to converse in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Region Operations Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","descriptionBodyPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5","applyUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718002291914,"descriptionPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","description":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","id":"f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","lists":[{"text":"What You Will Do","content":"<li>Monitor and analyze transactions and user activities to detect suspicious patterns and potential fraud.</li><li>Conduct thorough investigations of suspected fraud cases and recommend control actions.</li><li>Develop and implement strategies to mitigate fraud risks across the platform.</li><li>Collaborate with product, engineering, and operations teams to enhance fraud prevention measures.</li><li>Prepare detailed reports on fraud incidents, including root cause analysis and actionable recommendations.</li><li>Provide regular updates to senior management on fraud trends, risks, and mitigation efforts.</li><li>Stay updated on the latest fraud trends, tools, and best practices to continuously improve detection and prevention strategies.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Finance, Accounting, Business, Computer Science, or a related field.</li><li>2+ years of experience in fraud risk management or a related role.</li><li>Strong analytical and problem-solving skills, with proficiency in data analysis tools (e.g. SQL, Python, Excel) and experience with visualization tools (e.g. Tableau, DataStudio)</li><li>Excellent communication and interpersonal skills.</li><li>Ability to work independently and as part of a team in a fast-paced environment.</li><li>Strong attention to detail and commitment to accuracy.</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Risk Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","descriptionBodyPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","applyUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710738954272,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"60d37414-287e-4552-a0d0-accf1737d0ce","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>3-4 years of related payment risk experience, preferably on the acquiring side and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business side</li>"}],"text":"Risk Analyst - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce","applyUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce/apply"},{"additionalPlain":"In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1704856901936,"description":"","descriptionPlain":"","id":"5611e062-e094-4da3-ab1c-75c85cf62194","lists":[{"text":"What You Will Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volumes of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutions, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers&nbsp;</li>"},{"text":"What you will need","content":"<li>3+ years of experience developing ML solutions</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Risk Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194","applyUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713334327811,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"a61cda6c-82fd-4daf-aabf-3db91e01684f","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>5-8 years of related payment risk experience, preferably on the mobile apps and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business sid</li>"}],"text":"Risk Manager - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f","applyUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715584452832,"descriptionPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","description":"<div><b style=\"font-size: 16px\">About the team:</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","id":"d6ac496c-e0ad-4669-b594-ede9bf8d55f9","lists":[{"text":"What you will do:","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed,</li><li>Resolve account issues and complaints,</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis,</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments,</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation,</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients,</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms.</li>"},{"text":"What you will need:","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area,</li><li>A minimum of 3 years of experience in business management, sales, or project management is mandatory. </li><li>Prior experience in e-commerce and managing key accounts will be a plus point,</li><li>Fluency in both Bahasa and English is required,Able to multitask, prioritize, and manage time efficiently,</li><li>Ability to negotiate, persuade and influence others,</li><li>Excellent interpersonal, communication, presentation and analytical skills,</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills,</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners.</li>"}],"text":"Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the team:</b></div><div><span style=\"font-size: 16px;\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","descriptionBodyPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9","applyUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9/apply"},{"additionalPlain":"The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood campaigns.\n\nIn the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales team.When our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their efficiency.\n\nIn our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood </span><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">campaigns.</span></a></div><div><br></div><div><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales </span><a href=\"http://team.When\" class=\"postings-link\"><span style=\"font-size: 10pt\">team.When</span></a><span style=\"font-size: 10pt\"> our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their </span><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">efficiency.</span></a></div><div><br></div><div><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Excellence","allLocations":["Jakarta"]},"createdAt":1714365620212,"descriptionPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","description":"<div><span style=\"font-size: 10pt\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","id":"f39be622-e287-41df-bcb2-7389478a1be4","lists":[{"text":"What you will do","content":"<li>Oversee the performance tracking and monitoring of the whole Enterprise Sales Team</li><li>Ensure that the Enterprise Sales team has all the data they need to achieve their target for all KRs</li><li>Act as a consultant and discuss with the EKAMs on the business needs/challenges that their merchants are facing</li><li>Provide data and data driven insights to EKAMs to help address said challenges</li><li>Assist in performing periodical business analysis, tailored to each merchant based on their business needs</li><li>Assist in the daily tasks and smooth operations of Enterprise Sales Support</li><li>Liaise with HO team for merchant x sales account management, target, tracker, etc</li><li>Liaise with other teams (e.g. BI, Salestech) when there is new KRs / data point that needs to be analysed</li><div><br></div>"},{"text":"What you will need","content":"<li>At least 2 years of relevant experience in data analytics&nbsp;</li><li>Good business acumen, able to develop analysis with good storyline and flow</li><li>Proficient in SQL, Google BigQuery and the reporting thereof is an advantage</li><li>Proficient in handling large amount of data using tools/softwares such as google sheet, metabase and datastudio</li><li>Great communication and understanding skill, able to explain technical terms in simple, understandable manner</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>High interest and eagerness to analyse different parts of businesses to help achieve growth</li><li>Clear understanding of Gojek services and the tech industry</li><div><br></div>"}],"text":"Sales Support Senior Associate, Enterprise","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","descriptionBodyPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4","applyUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4/apply"},{"additionalPlain":"About The Team\n\nOur Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1720004794044,"descriptionPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","id":"bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","lists":[{"text":"What You Will Do","content":"<li>Identify areas of business growth by structuring problem statements and forming hypotheses</li><li>Query and process large amounts &amp; complex data sets of our customers’ behavior, usage patterns, statistical trends, and funnel performance&nbsp;&nbsp;</li><li>Synthesize actionable insights and solutions from the data analysis</li><li>Own and drive the proposed initiatives to achieve business objectives</li><li>Visualize and communicate findings in an easy-to-understand, concise, and clear format</li><li>Experiment with the growth initiatives and continuously iterate to find areas for improvements</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience working in a data-driven environment, previous experience in the tech industry is a bonus</li><li>Proficient in data query, data processing, and charting to synthesize actionable insights from large sets of complex data</li><li>Strong structured problem-solving abilities to identify issues, form hypotheses, and generate recommendations</li><li>Ability to create and execute experimentation plans or A/B testing on key growth initiatives&nbsp;</li><li>Excellent project and stakeholder management skills to ensure all planned initiatives are met on high quality and on time</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Ability to learn new things and adapt your priorities quickly within a fast-paced environment</li>"}],"text":"Savings Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","descriptionBodyPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","applyUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1698657930091,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"376aefd9-6d6c-4e57-8040-a3b0dd416d26","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2 to 4 years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26","applyUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719471574933,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2-4+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","applyUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Consumer Experience","allLocations":["Bengaluru"]},"createdAt":1716277072995,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"0169bd4d-f352-4162-8e8e-2c09df5b8db4","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Growth","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4","applyUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788743352,"descriptionPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","id":"08aa1472-d91f-4c5d-b5e0-e88163943bcd","lists":[{"text":"What You Will Do","content":"<li>Design, implement, and maintain the company’s IT infrastructure, ensuring scalability, reliability, and performance.</li><li>Manage servers, networks, databases, and cloud services to support business operations and growth.</li><li>Develop and implement comprehensive cybersecurity strategies to protect the company’s assets and data.</li><li>Conduct regular security assessments, vulnerability scans, and penetration testing to identify and mitigate risks.</li><li>Oversee the installation, configuration, and maintenance of hardware and software systems.</li><li>Ensure data integrity and availability through effective backup and disaster recovery planning.</li><li>Develop and enforce IT policies and procedures to ensure security, compliance, and efficient operations.</li><li>Ensure compliance with relevant regulations and industry standards.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, Information Technology, or a related field. A Master’s degree or relevant certifications (e.g., CISSP, CISM) is a plus.</li><li>Minimum of 7 years of experience in IT infrastructure management, cybersecurity, or a related role, with at least 3 years in a leadership position, preferably in the cryptocurrency or fintech industry.</li><li>Strong understanding of IT infrastructure, network administration, and cybersecurity practices.</li><li>Proven track record of developing and implementing successful IT and security strategies.</li><li>Excellent analytical, problem-solving, and organizational skills.</li><li>Strong leadership, communication, and interpersonal skills.</li><li>Preference qualifications in high-frequency trading</li>"}],"text":"Security and System Infra Manager (CISSP) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd","applyUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd/apply"},{"additionalPlain":"About the Team\n\nThe Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial <a href=\"http://platforms.It\" class=\"postings-link\">platforms.It</a> is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719832381686,"descriptionPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","id":"9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","lists":[{"text":"What You Will Do","content":"<li>Perform security design on applications (web, mobile) and infrastructures (cloud, on-premise)</li><li>Perform security code review (manual, automated) on applications and infrastructures</li><li>Ensure applications and infrastructures are secure by design, follow secure design principles, and adopt secure coding practices</li><li>Identify security gaps and vulnerabilities, and propose appropriate controls and remediations</li><li>Propose solutions to wide-ranging security problems</li><li>Raise security awareness among the Product, Engineering, and Infrastructure team by conducting security training, and having regular security discussions</li><li>Bridge communication between the broader Information Security team with the Product, Engineering, and Infrastructure team</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, or a related field</li><li>Minimum 3 years of experience in Software Engineering, preferably on web and mobile application</li><li>Minimum 3 years of experience in Information Security, preferably in application and cloud security</li><li>Good knowledge of common secure design principles and secure coding practices</li><li>Good knowledge of common adversarial techniques, tactics, and procedures&nbsp;</li><li>Ability to learn new things quickly and independently</li><li>Ability to communicate effectively, preferably in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Security Engineering Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","descriptionBodyPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","applyUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12/apply"},{"additionalPlain":"About the Team \n\nMxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).\n\nCore areas that we focus on - \nDeveloper Experience and Tooling: We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.\n\nFoundation and Building Blocks: This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!\n\nApp Excellence and Insights Tooling: The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">MxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).</span></div><div><br></div><div><b style=\"font-size: 16px\">Core areas that we focus on - </b></div><div><b style=\"font-size: 16px\">Developer Experience and Tooling: </b><span style=\"font-size: 16px\">We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.</span></div><div><br></div><div><b style=\"font-size: 16px\">Foundation and Building Blocks:</b><span style=\"font-size: 16px\"> This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!</span></div><div><br></div><div><b style=\"font-size: 16px\">App Excellence and Insights Tooling: </b><span style=\"font-size: 16px\">The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697010103248,"descriptionPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","id":"3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","lists":[{"text":"What You Will Do ","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need ","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Android Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px;\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","applyUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b/apply"},{"additionalPlain":"About the Team\n\nThe Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.\n\nCTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.</div><div><br></div><div>CTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721369663762,"descriptionPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","id":"767d8980-5402-488d-b62c-222c0b4a0bfc","lists":[{"text":"What You Will Do","content":"<li><b>Observe</b>: Monitor the surface, deep, darkweb, and listen to your intelligence-sharing circles.</li><li><b>Analyze</b>: Through understanding of the internal landscape assess the (predicted threat). Support the incident response investigation, when needed.</li><li><b>Disrupt</b>: disrupt the effectiveness of the threats by various means.</li><li><b>Report</b>: Communicate timely, simply, and effectively the threat and key recommendations.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, Networking, and Cyber Security.</li><li>Working experience with one or multiple categories of tools (open source or commercial): Link Analysis Tools, Threat Modeling Tools, (Threat) Feed Aggregators, Threat Intelligence Platforms (TIP’s), Digital Risk Protection platforms, Malware Sandboxes, SOAR, SIEM or EDR.</li><li>5-7 Years of working experience (strong mid-level or senior in cyber security), relevant degree (bachelor or higher), or reputable industry certification (e.g.: ISC2, GIAC, Offsec, EC Council) preferred.</li><li>Extensive working experience in the CTI field is preferred, candidates from the following affiliated fields are alternatively also preferred: SOC, Vulnerability Management (VAPT), Penetration Testing, or Digital Forensics Incident Response (DFIR).</li><li>Possess critical thinking and problem-solving skills.</li><li>Leadership, experience in mentoring junior members, and stakeholder management skills are a must. You will be leading multiple important initiatives across the teams/companies.</li><li>Proficiency in English and Indonesian, both in written and oral form.</li><li>Outstanding reporting skills: content, delivery, clarity, brevity, and presentation.</li>"}],"text":"Senior Cyber Threat Intelligence Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt;\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","descriptionBodyPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc","applyUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719213882004,"descriptionPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","description":"<div><b style=\"font-size: 10pt\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","id":"1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","lists":[{"text":"What you will do","content":"<li><b>Design, build, and maintain the ETL </b>from various sources into the data mart; Troubleshoot and resolve data-related issues, including data discrepancies, anomalies, and performance bottlenecks</li><li>End to end data project ownership and collaboration with cross-functional teams to understand data requirements and design data models that support the organization's single version of truth</li><li>Ensure the quality, accuracy, and reliability of our data by implementing data validation checks and error handling mechanisms</li><li>Develop and customize Tableau/Google Sheet/Looker studio reports that provide actionable insights to stakeholders</li><li>Create and maintain documentation related to data structures, processes, and transformations for future reference</li>"},{"text":"What you will need","content":"<li>4 years of experience in <b>Data Analyst/BI Analyst/</b>BI Engineer</li><li>Advance knowledge of <b>SQL </b>and Python</li><li>Able to lead a small team also can work as a individual contributor</li><li>Hands on experience with data visualization Tableau Looker studio/Google Sheet</li><li>Strong analytical and problem-solving skills, with keen attention to detail</li><li>Excellent communication skills (English is a must) to collaborate with technical and non-technical stakeholders</li><li>Having a people manager experience is a plus</li>"}],"text":"Senior Data Analyst (Analytics Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","descriptionBodyPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","applyUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264696268,"descriptionPlain":"\n","description":"<div><br></div>","id":"6d8ebb73-2348-423d-847e-b8a8408ac1ed","lists":[{"text":"What You Will Do","content":"<li>Gather business requirements to support BI projects.</li><li>Explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What you will need ","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Senior Data Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed","applyUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed/apply"},{"additionalPlain":"Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719472943608,"descriptionPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","description":"<div><span style=\"font-size: 10pt\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","id":"90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","lists":[{"text":"What You Will Do","content":"<li>Design, build, and maintain data streaming solutions.</li><li>Troubleshoot and resolve data-related issues, including discrepancies, anomalies, and performance bottlenecks.</li><li>Ensure scalability and reliability of the data streaming platform.</li><li>Collaborate with data engineers, data scientists, and other stakeholders to understand requirements and provide tailored streaming solutions.</li><li>Monitor and optimise performance to ensure low latency and high throughput.</li><li>Perform regular maintenance tasks, including upgrades and patches.</li><li>Document design, implementation, and maintenance processes.</li><li>Stay updated with the latest advancements in data streaming technologies.</li>"},{"text":"What You Will Need","content":"<li>3 - 6 years of experience as a Data Engineer.</li><li>Strong programming skills in Java.</li><li>Hands-on experience in real-time streaming with Apache Flink.</li><li>Experience working with Apache Kafka and Kubernetes.</li><li>Experience working with any cloud platform and NoSQL database.</li><li>Strong analytical and problem-solving skills, with keen attention to detail.</li><li>Excellent communication skills for collaborating with technical and non-technical stakeholders.</li><li><b>Good to have: </b>Programming in Go/Python, IAC using Terraform, Batching ETL and exposure to open data lakehouse architecture is a plus</li><li><br></li>"}],"text":"Senior Data Engineer - Data Streaming","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","descriptionBodyPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","applyUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720774001435,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"976d0171-5a06-43e2-9ec6-e0b45345c6fd","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd","applyUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd/apply"},{"additionalPlain":"About The Team\nThe GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><span style=\"font-size: 10pt\">The GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1684915963454,"descriptionPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","description":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","id":"a539cdc1-109f-48e8-9b24-1a831b735f01","lists":[{"text":"What Will You Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volume of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers</li>"},{"text":"What You Will Need","content":"<li>6+ years of experience developing ML solutions, 2-3 years of <b>fraud risk experience in account takeover, scam, and abuse</b></li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt;\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","descriptionBodyPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01","applyUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1713852044349,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"34f6146a-c482-407c-a31c-72ac9bb90a7c","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>Analyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist - Marketplace (Singapore)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c","applyUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1705993404249,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"86673189-b5e2-4ace-b1a3-5ab20f14d84d","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist (India)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d","applyUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707210044551,"descriptionPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","description":"<div><span style=\"font-size: 10pt\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","id":"c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","lists":[{"text":"What You Will Do","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What You Will Need","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li>"}],"text":"Senior Data Warehouse Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","descriptionBodyPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","applyUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69/apply"},{"additionalPlain":"About The Team\n\nOur Data Warehouse team is based in Jakarta & Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nOur team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data Warehouse team is based in Jakarta &amp; Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1713498805305,"descriptionPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","description":"<div><span style=\"font-size: 10pt\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","id":"2b430ba4-210e-4db6-a63e-c11459a0304f","lists":[{"text":"What Will You Do?","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What Do You Need? ","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li><li>You’re passionate about your customers and always bring questions back to what will serve them best</li>"}],"text":"Senior Data Warehouse Engineer - India","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt;\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","descriptionBodyPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f","applyUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f/apply"},{"additionalPlain":"About the Team\n\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719199384298,"descriptionPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"905d4e32-1699-4fcc-96b3-aa6aa0b462cb","lists":[{"text":"What You Will Do","content":"<li>Analyze database performance data to identify bottlenecks and implement optimizations to enhance system efficiency and reliability</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li><li>Design and develop custom tools and utilities to facilitate various database operations, leveraging programming languages such as Ruby, or Golang</li><li>Ensure database security best practices are implemented and maintained, including access control, encryption, and compliance with relevant regulations</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Continuously evaluate database infrastructure usage and performance metrics to identify opportunities for cost optimization</li><li>Benchmarking tests to evaluate the impact of configuration changes on database performance. This helps in identifying optimal parameter values and fine-tuning configurations for different types of workloads.</li><li>Tuning database configuration parameters to optimize database performance for the application</li>"},{"text":"What You Will Need","content":"<li>8+ years experience as a DBA Engineer in managing databases for a large production environment</li><li>Expert in various database management systems (MySQL/PostgreSQL, Redis, MongoDB, and Elastic Search), and techniques for optimizing databases and understanding the basic cloud platform (AWS or GCP)</li><li>Advanced skills in a programming language like Ruby or Golang, and possess deep expertise in shell scripting</li><li>Excellent experience with Linux is required and expertise in server configuration, maintenance, and troubleshooting</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)</li><li>Proficient in seamlessly conducting database upgrades, ensuring uninterrupted operations and system integrity.</li><li>Proficiency in configuring and utilizing monitoring and diagnostic tools to pinpoint and address database performance issues effectively</li><li>In-depth knowledge of the various configuration parameters tailored to the specific database management system</li>"}],"text":"Senior Database Administrator Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb","applyUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb/apply"},{"additionalPlain":"About the Team\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719198420770,"descriptionPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"28fe323b-ed5f-482b-b71d-ed60662bed8b","lists":[{"text":"What You Will Do","content":"<li>Develop automation scripts and tools for provisioning, deployment, monitoring, and backup/recovery of databases using infrastructure as code (IaC) principles</li><li>Implement robust monitoring and alerting systems for database performance metrics&nbsp;</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Maintain version-controlled configurations for database servers, ensuring consistency and repeatability across environments via IaC</li><li>Automate routine tasks such as database backups, schema migrations, and data archiving to improve operational efficiency</li><li>Develop database high availability and replication solutions to meet the requirements of critical applications.</li><li>Develop standardized operational procedures within the DBaaS framework to ensure the consistent provision of highly available solutions.</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li>"},{"text":"What You Will Need","content":"<li>5+ years Experience as a DevOps Engineer with a focus on database management</li><li>Hands-on experience with cloud platforms (AWS or GCP)</li><li>Proficiency in scripting languages such as Go, Shell, and Ruby for automation tasks</li><li>Experience with infrastructure as code tools (e.g., Terraform, CloudFormation) for provisioning and managing database resources</li><li>In-depth knowledge of database systems such as MySQL, PostgreSQL, MongoDB, etc., including configuration, optimization, and troubleshooting</li><li>Strong understanding of CI/CD practices and tools</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)&nbsp;</li><li>Experience in configuration management tools (eg: ansible) for database patching and maintenance automation</li>"}],"text":"Senior DevOps Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b","applyUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1706508052225,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","id":"da8d4a37-f5a4-4436-8743-58c787781285","lists":[{"text":"What You Will Do","content":"<li>Take ownership of one of OKR related to demand and growth that leads to revenue and profitability from one of Gojek product’ business; defines the strategy and roadmap for the team to achieve it by combining multiple initiatives (e.g., content/communication, vouchers/promotion, product changes)</li><li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Build predictive model or clustering model to allocate the promo allocation efficiently</li><li>Run multiple experiments to validate hypothesis in fast pace iteration cycle</li><li>Drives the team for prioritization, strategy, and focus on solutions to solve user problems</li><li>Introduce beneficial business changes through well-written strategy documents and validate the strategy and hypotheses through robust experimentation and statistical approach</li><li>Optimize and automate solutions by leveraging Data Sciences resources</li><li>Perform feedback loop and retroactive analysis of the team performance and operation to evaluate and improve their impact on Gojek’'s North Star Metrics</li><li>Proactively review the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Present findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis.</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 5 years of working experience with a minimum of 1-2 year of leadership experience</li><li>Proficiency in data analysis tools and programming languages such as Python, R, SQL, and data visualization tools like Tableau or Power BI. Strong analytical skills to interpret complex data sets and extract actionable insights</li><li>High proficiency in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficiency in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Understanding of business operations, strategies, and objectives. The Consumer Analytics Lead should be able to connect analytical insights to business goals and contribute to overall decision-making</li><li>Data Management: Familiarity with data collection, storage, and management best practices</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Experience in a SaaS, Marketplace, Food Delivery, or other technology company is a plus</li>"}],"text":"Senior Growth Manager - Food & Ads","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285","applyUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285/apply"},{"additionalPlain":"About The Team\n\nThe mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.\n\nThe Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.\n\nIn addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.</div><div><br></div><div>The Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.</div><div><br></div><div>In addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.</div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Jakarta","team":"-","allLocations":["Jakarta","Bengaluru"]},"createdAt":1721729849780,"descriptionPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","description":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","id":"e6583aa0-7097-4e6f-9f91-7f24d5441156","lists":[{"text":"What You Will Do","content":"<li>Develop and communicate a clear product vision and roadmap for data science/GenAI platforms/products, and Streaming/Batching Pipeline products.</li><li>Lead the end-to-end product development lifecycle from ideation through launch and iteration, aligning product strategies with business objectives and stakeholder needs.</li><li>Collaborate closely with cross-functional teams, including engineering, data science, analytics, and operations, to deliver high-quality products.</li><li>Prioritize features and improvements based on data analysis, user feedback, and business impact.</li><li>Utilize data-driven insights to inform product decisions and measure the impact of product features.</li><li>Implement and track key performance indicators (KPIs) to ensure product success and drive continuous improvement.</li><li>Foster a culture of experimentation and iteration to optimize product performance and user satisfaction.</li><li>Communicate product updates, progress, and challenges effectively to stakeholders at all levels of the organization.</li>"},{"text":"What You Will Need","content":"<li>5+ years of product management experience, specializing for at least 3 years in data science platforms, data pipelines, or related products.</li><li>Proven track record of successfully managing complex technical products in fast-paced environments.</li><li>Strong understanding of data science, and data engineering principles.</li><li>Experience with streaming and batching data processing technologies such as Apache Kafka, Spark, Flink, etc will be a big plus.</li><li>Strong analytical and problem-solving skills, leveraging a data-driven approach to decision-making.</li><li>Excellent verbal and written communication skills.</li><li>Demonstrated leadership abilities, capable of inspiring and motivating cross-functional teams.</li>"}],"text":"Senior Product Manager, Data Science Platform and Data Products","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156","applyUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156/apply"},{"additionalPlain":"About The Team\n\nOur Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. </div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1717126992883,"descriptionPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","id":"50c8a826-2076-40a3-a829-b96b29c9647f","lists":[{"text":"What You Will Do","content":"<li>Conduct research to understand merchants needs and behavior and analyze product performance data to identify opportunities&nbsp;</li><li>Developing and executing a data-driven marketing strategy that aligns with the overall business objectives</li><li>Create product positioning and messaging to differentiate our products from competitors</li><li>Creating and managing marketing campaigns across various channels, including search, social media, and email marketing by working together with both internal and external stakeholders to deliver the plan</li><li>Developing and managing referral or other marketing programs to drive merchant acquisition</li><li>Identify, develop, implement, and refine consumer-focused lifecycle &amp; retention marketing strategies</li><li>Continuously monitor and analyze data to create campaign or marketing reports</li><li>Running A/B tests and analyzing results to optimize conversion rates and user acquisition.</li>"},{"text":"What You Will Need","content":"<li>3+ years working experience in Tech, Bank, Consulting or Marketing Agencies</li><li>2+ years experience in marketing or growth roles</li><li>Customer obsession and passionate in marketing</li><li>Strong analytical skills, data-driven and delighted with statistical analysis and figures</li><li>Strong communication skills, collaborative spirit, delighted to work with other stakeholders (BI/Data, Business, Product, Leadership)</li><li>Strong business sense and problem-solving skills</li>"}],"text":"Senior Product Marketing Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f","applyUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f/apply"},{"additionalPlain":"About The Team\n\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1722243132222,"descriptionPlain":"About The Role\n\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","id":"afd9e752-82f0-4b4f-a4ef-5d86dcce1063","lists":[{"text":"What You Will Do","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed</li><li>Resolve account issues and complaints</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms</li>"},{"text":"What This Role Needs","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area</li><li>At least 6 years of experience in business management, sales, or project management is mandatory. Prior experience in e-commerce and managing key accounts will be a plus point</li><li>Fluency in both Bahasa and English is required</li><li>Able to multitask, prioritize, and manage time efficiently</li><li>Ability to negotiate, persuade and influence others</li><li>Excellent interpersonal, communication, presentation and analytical skills</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners</li>"}],"text":"Senior Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","descriptionBodyPlain":"About The Role\n\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063","applyUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063/apply"},{"additionalPlain":"About the Team\n\nThe Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721742951306,"descriptionPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","description":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","id":"099498bc-c171-4505-97d7-3a432d302e14","lists":[{"text":"What You Will Do","content":"<li>Work and collaborate in Financial systems technical projects, especially in SAP ABAP and SAP BTP technologies</li><li>Collaborate with cross-functional and cross-department teams to analyze complex business requirements and design scalable solutions</li><li>Develop and maintain technical specifications, design documents, and other project artifacts</li><li>Provide technical support and guidance to development teams, ensuring high-quality code delivery</li><li>Participate in code reviews, ensuring adherence to coding standards and best practices</li><li>Contribute to the development of technical architecture and design patterns, providing recommendations for improving performance, scalability, and maintainability</li><li>Stay up-to-date with the latest SAP technologies and trends, and evaluate new technologies for potential adoption</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of experience in SAP application development, with a focus on SAP ABAP and SAP BTP technologies</li><li>Proven track record of delivering successful scalable technical projects</li><li>Strong technical skills in ABAP OO, SAP Gateway, CDS, AMDP</li><li>Strong technical skills in SAP BTP or SAP Integration Suite</li><li>Knowledge on modern integration, Unix environment, cloud platform technologies, and other stacks is a plus</li><li>Excellent communication and interpersonal skills, with the ability to work effectively in a team environment</li><li>Strong analytical and problem-solving skills, with the ability to think creatively and strategically</li>"}],"text":"Senior SAP Technical","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","descriptionBodyPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14","applyUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1706837996316,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"93b5e2e0-272f-4091-b7aa-fafc06ca67c4","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>4-6+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"Senior SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4","applyUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4/apply"},{"additionalPlain":"About our Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About our Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1700733541559,"descriptionPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","description":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","id":"472ae629-87cb-4f8c-bb69-eae35cf3751e","lists":[{"text":"What you’ll do","content":"<li>Develop and implement test automation tools and frameworks to ensure continuous testing of product features</li><li>Collaborate with product managers and engineers to understand requirements, document test cases, and define rollout/release strategies</li><li>Perform performance, load, and scalability testing for new features and product releases.</li><li>Debug and diagnose defects uncovered during testing to determine root causes. Log bugs accurately and communicate issues clearly to engineering teams</li><li>Monitor systems in production to identify and troubleshoot defects or anomalous behavior.</li><li>Stay up-to-date with new testing methodologies and tools</li><div><br></div><div><br></div>"},{"text":"What you’ll need","content":"<li>5+ years experience in a QA, SDET or DevX role, with expertise in test automation</li><li>Proficiency with one or more programming languages like Java, Go, Kotlin, Python</li><li>Experience testing complex distributed systems and microservices architectures</li><li>Understanding of SQL and NoSQL databases</li><li>Familiarity with technologies like Kafka, Docker, Kubernetes</li><li>Knowledge of financial systems, mobile apps, or SaaS products is a plus</li><li>Excellent verbal and written communication skills</li>"}],"text":"Senior SDET - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e","applyUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721811900324,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","id":"153e42ca-cf5b-4f43-b09e-58eabda1e5fa","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 4 years of experience in professional testing in App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin, experience with Flutter is a plus)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa","applyUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1713506558950,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"076bd021-0157-42a4-89fd-51d9f236e490","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Payment Widget & Vendor Gateway","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490","applyUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490/apply"},{"additionalPlain":"About the Team\n\nThe Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.\n \nSome of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few. \n \nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.</div><div>&nbsp;</div><div>Some of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few.&nbsp;</div><div>&nbsp;</div><div>Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Marketplace","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1698659237440,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","id":"8d7ae844-168c-4e78-843a-94aceb7b1a66","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of relevant, hands-on experience with either  Golang, or Java</li><li>Ability to go in-depth across tech stacks used in the product</li><li>Experience working on large-scale, event-driven microservice architecture with active use of Kafka; ability to architect solutions based on this pattern</li><li>Familiarity with basic programming principles such as SOLID and TDD</li><li>Intermediate experience with Linux OS; ability to troubleshoot issues</li><li>A solid understanding of why we need to test code; experience implementing tests</li><li>Ability to understand/discuss design and performance trade-offs in complex systems</li>"}],"text":"Senior Software Engineer  - Marketplace","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66","applyUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711358848361,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"68f907a3-329f-411b-af2d-a66b38243919","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 5 years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>You have working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>You have Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, XGBoost, Keras</li>"}],"text":"Senior Software Engineer - Data Science Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919","applyUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919/apply"},{"additionalPlain":"About the Team\n\nWe are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.\n\nWe keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.\n\nThe Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.</span></div><div><br></div><div><span style=\"font-size: 16px\">We keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.</span></div><div><br></div><div><span style=\"font-size: 16px\">The Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721898140037,"descriptionPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","id":"57bb5e7f-9ea0-462f-ac36-5717b49d0380","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li><div><br></div>"},{"text":"What You Will Need","content":"<li>4-5 years of relevant experience. Hands-on in either Golang or Java</li><li>The ability to go into depth and breadth across tech stack used in the product vis-a-vis backend services, machine learning, data engineering, web development, data and analytics, infrastructure</li><li>Has worked on large scale event driven microservices architecture with an active use of Kafka and can architect solutions based on this pattern</li><li>Is familiar with basic programming principles such as SOLID and TDD</li><li>Has intermediate experience with Linux and is able to troubleshoot issues</li><li>Understands why we need to test code and has implemented tests</li><li>Able to understand/discuss design and performance trade offs in complex systems</li><div><br></div>"}],"text":"Senior Software Engineer - Go-food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px;\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380","applyUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718187134939,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"53c0b8a9-1a83-4c34-9a59-b5170ce54193","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Senior Software Engineer - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193","applyUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789054175,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","id":"fda395d6-457d-4a03-aaa1-33d513c3960b","lists":[{"text":"What You Will Do","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Software Engineer (Android) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b","applyUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b/apply"},{"additionalPlain":"About the Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713939159820,"descriptionPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","id":"d3b7122b-692b-4815-8aa9-f1d0259bccd5","lists":[{"text":"What Will You Do","content":"<li>Develop Java backend applications for the company, including web applications and server-side applications.</li><li>Be responsible for participating in the entire software development process, from requirement analysis to design, development, testing, and deployment, ensuring that our software products run efficiently and stably. The most significant thing is taking responsibility for results.</li><li>Architect and engineer robust, high-performance systems that can effortlessly handle scale, maintain reliability, ensure security, and gracefully handle faults.</li><li>Craft and refine our product vision into iterative Minimum Viable Products (MVPs), refining them as needed for scalability and adaptability.</li><li>Stay at the forefront of technology trends, continuously evaluating and incorporating new tools and methodologies to supercharge our development efforts.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","descriptionBodyPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5","applyUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789283382,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","id":"769b7391-e6fd-4923-9a92-e060f14e451d","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis, and MySQL.</li><li>Contributed to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization. Therefore, in addition to technical prowess, a keen understanding of financial business and self-motivation are emphasized.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>3+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Highly preferable experience in Golang</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d","applyUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d/apply"},{"additionalPlain":"About the team \n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the team </b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713777541586,"descriptionPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","description":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","id":"ad7a1160-4d07-4f4a-a2d3-c362afac18ac","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis and MySQL</li><li>Contribute to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred</li><li>Familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis</li><li>Familiar with Linux operating systems, understand database principles, and proficient in using databases like MySQL and Oracle</li><li>Good coding style and code specifications, and be able to independently complete project development</li><li>Good communication skills and teamwork spirit, and be able to collaborate effectively with other developers</li><li>knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Backend) - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","descriptionBodyPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac","applyUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710229562529,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"10dbc666-80f8-4250-85ee-59fa92d056aa","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Golang.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Good understanding of the full life cycle of the data warehouses.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Data Warehouse)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa","applyUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788927036,"descriptionPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","id":"bcd00ee0-2fb3-43c1-8401-ef184283ccc8","lists":[{"text":"What You Will Do","content":"<li>Design, build, deliver, and own development lifecycle from inception to production</li><li>Collaborate with the UI/UX team to write, design, and build high-quality front-end code and reusable components</li><li>Participate in and be responsible for front-end architecture design, and program decision-making, as well as creating technical standards and specifications;</li><li>Try improving engineering standards, tooling, and processes after understanding the business and team’s needs</li><li>Lead others through example, mentorship, teaching, code reviews, advocating, and maintaining suitable engineering standards for the team</li><li>Maintain close relations cross-department and gain from their expertise/share your learnings with them</li>"},{"text":"What You Will Need","content":"<li>3-4+ years of proven track record in JavaScript/ Typescript, CSS , HTML, DOM, network protocol, and other front-end related technologies, have in-depth experience in at least one of the mainstream front-end frameworks (React/ Vue /Angular, etc.) and understand the implementation principle</li><li>Good product awareness, service awareness, and sense of responsibility, can be independent and attention to user experience</li><li>Problem-Solving: Exceptional problem-solving skills with a track record of analyzing complex technical challenges and providing innovative solutions.</li><li>Communication: Excellent communication skills, with the ability to effectively convey technical concepts to both technical and non-technical stakeholders.</li><li>Leadership: Strong leadership experience, including mentorship, and technical guidance</li>"}],"text":"Senior Software Engineer (Front End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8","applyUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789167169,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","id":"e6c36118-5d4e-444b-922c-68e03c2ab82e","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Flutter and iOS.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3+ years of experience with iOS development and Flutter combined</li><li>Proficient in Swift programming, Cocoa, Xcode, the iOS SDK, Dart, and Flutter</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar).</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e","applyUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1708271973710,"descriptionPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","id":"389c0346-14e0-40e5-85c3-48d830db73b4","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Swift.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3 to 6+ years of experience with iOS development</li><li>Proficient in Swift programming, Cocoa, Xcode, and the iOS SDK</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar)</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Money Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","descriptionBodyPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4","applyUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899734506,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"449dd201-2d4d-47a0-9cd4-c7ddec91c88e","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data streaming products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Java.</li><li>Good understanding of real-time data streaming technologies like Flink, spark etc.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Real-Time Data Streaming)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e","applyUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1716821917651,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"8afd4278-a5a8-43f2-8718-2986433f2ddb","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.&nbsp;&nbsp;</li>"}],"text":"Senior Technical Program Manager - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb","applyUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717153383212,"descriptionPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","description":"<div><span style=\"font-size: 9pt\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","id":"3377f50a-d56f-42e0-acc5-b69d405a37a9","lists":[{"text":"What You Will Do","content":"<li>Identify and pursue strategic partnership opportunities that align with company goals - B2B in financial and non financial sectors</li><li>Negotiate terms and agreements with partners to drive mutual commercial successDevelop and maintain strong relationships with external partners to foster long-term collaboration</li><li>Collaborate with partners to create joint business plans aimed at achieving quarterly (QoQ) and yearly (YoY) growth targets</li><li>Monitor and analyze partnership performance, providing insights and recommendations for improvement</li><li>Work closely with internal teams, including sales, marketing, product, and finance, to ensure partnership initiatives are aligned with company objectives and obtain their successful buy in to projects and programs</li><li>Facilitate effective communication and collaboration across departments to gain buy-in for partnership strategies</li><li>Act as a liaison between partners and internal stakeholders to address any issues and optimize partnership outcomes</li><li>Be the first hand to handle issues related to the partnership and escalate the issue to the right parties (internal and external) to be solved</li><div><br></div>"},{"text":"What You Will Need ","content":"<li>Minimum Bachelor’s degree</li><li>Minimum 5 years of professional experience in partnership development or business development in companies such as start-ups, technology companies, management consulting, banking, or Fortune 500 companies</li><li>Data Analysis: Strong ability to crunch data and perform detailed data analysis. This includes interpreting complex datasets to derive actionable insights and support decision-making.</li><li>P&amp;L Understanding: Good understanding of Profit and Loss statements, with the ability to analyze financial performance and identify <a href=\"http://trends.Business\" class=\"postings-link\">trends.</a></li><li><a href=\"http://trends.Business\" class=\"postings-link\">Business</a> Acumen: Solid business acumen, enabling the development, management, and execution of business agreements and contracts. This involves a deep comprehension of business operations and strategic <a href=\"http://planning.Critical\" class=\"postings-link\">planning.</a></li><li><a href=\"http://planning.Critical\" class=\"postings-link\">Critical</a> Thinking and Problem Solving: Draws sound conclusions based upon a mixture of analysis and experience. Able to identify breakthrough solutions during tough negotiations or large-scale implementations with strategic <a href=\"http://partners.Communications\" class=\"postings-link\">partners.</a></li><li><a href=\"http://partners.Communications\" class=\"postings-link\">Communications</a> Skills: Promotes an environment of open communication. Convinces and engages others by using compelling arguments. Able to rigorously manage a portfolio of projects with strategic partners, unblock issues &amp; risks and manage expectations to ensure they are completed within target timelines and stakeholder <a href=\"http://expectations.Stakeholder\" class=\"postings-link\">expectations.</a></li><li><a href=\"http://expectations.Stakeholder\" class=\"postings-link\">Stakeholder</a> Management: Ability to develop strong, long lasting relationships with both internal and external stakeholders at all levels. Persuades and influences effectively by building support for ideas and initiatives through the effective presentation of facts and evidence. Identifies and anticipates that the partner and stakeholder needs to gain their commitment. Owns the end-to-end relationship with equivalent team and functional leads both internally and <a href=\"http://externally.B2B\" class=\"postings-link\">externally.</a></li><li><a href=\"http://externally.B2B\" class=\"postings-link\">B2B</a> Negotiation Skills: A fair, unbiased mediator and uses diplomacy and tact to diffuse tense situations comfortably</li><li>Resiliency : Demonstrates resilience &amp; composure, even in difficult or adverse circumstances. Makes and carries through unpopular or difficult decisions that are in the best interest of the team. Is able to resist the pressure to make quick decisions where due consideration is <a href=\"http://required.Abilities\" class=\"postings-link\">required.</a></li><li><a href=\"http://required.Abilities\" class=\"postings-link\">Abilities</a> to navigate and execute in a highly ambiguous environmentLocal candidates is a must</li><div><br></div>"}],"text":"Senior/Partnership Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt;\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","descriptionBodyPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","hostedUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9","applyUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9/apply"},{"additionalPlain":"About the Team\n\nAs a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.\n\nOur team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>As a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.</div><div><br></div><div>Our team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705293453270,"descriptionPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","id":"9b2d9240-3315-4b28-a7d6-73e2a097c8d7","lists":[{"text":"What You Will Do","content":"<li>Proactively monitor and troubleshoot system performance, identifying and addressing potential issues.</li><li>Collaborate with development teams to design and implement scalable and resilient system architectures.</li><li>Develop and maintain automation tools to streamline processes and enhance overall system efficiency.</li><li>Participate in incident response activities, conducting root cause analysis</li><li>Contribute to the ongoing improvement of reliability, scalability, and performance of critical infrastructure.</li><li>Work closely with cross-functional teams to align SRE efforts with broader organizational goals.</li>"},{"text":"What You Will Need","content":"<li>Solid understanding of cloud platforms such as GCP, and expertise in deploying and managing services within these environments.</li><li>In-depth knowledge of containerization technologies like Docker and orchestration tools such as Kubernetes</li><li>Proficiency in programming languages like Python, Go, or Java, with a strong software engineering foundation</li><li>Able to manage small teams and also can work as an individual contributor</li><li>Familiarity with Linux System, monitoring and logging tools to ensure comprehensive system visibility such as Prometheus, Grafana, and ELK stack</li><li>Proven track record of implementing and maintaining automation for deployment, scaling, and system orchestration.</li>"}],"text":"Site Reliability Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","descriptionBodyPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7","applyUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7/apply"},{"additionalPlain":"About the Team \n\nOur Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.\n\nHaving a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.  \n\nWe are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Our Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.</div><div><br></div><div>Having a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.&nbsp;&nbsp;</div><div><br></div><div>We are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717664713208,"descriptionPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","id":"f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","lists":[{"text":"What Will You Do ","content":"<li>Be the person in charge to create social media campaign and content; from observing trends and references, brainstorming, planning to execution (including schedule and post)</li><li>Develop social media campaigns strategies collaborate with other stakeholders&nbsp;&nbsp;</li><li>Create KOL strategy collaborate with stakeholders and third parties</li><li>Utilizing social media tools to analyze social media campaign, content, and KOL to gather insight and action plan</li><li>Collaborate with brand marketing to deliver/support marketing needs</li>"},{"text":"What Will You Need","content":"<li>At least 3-5 years related work experience from an advertising agency or start-up</li><li>Strong writing, editing, and proof-reading skills</li><li>Ability to communicate ideas clearly; a strong analytical, data-driven mindset</li><li>Broad knowledge of social media landscape, platforms, and technologies</li><li>Have interest in digital platforms, particularly in social media, and a willingness to learn more about this digital space</li><li>Strong team player with a proactive attitude and a creative/innovative mind to collaborate with multiple stakeholders</li><li>Strong analytical abilities to read, interpret, and utilize data, and to come up with actionable points for optimization and/or experimentation</li><li>Robust and detail-oriented to handle multiple works</li>"}],"text":"Social Media Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","descriptionBodyPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","applyUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898426994,"descriptionPlain":"\n","description":"<div><br></div>","id":"180b3e9e-cfb9-471d-8c30-410aef031535","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features &amp; participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team &amp; be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment &amp; work closely on the production environment, maintaining product’s&nbsp; uptime, reliability and SLOs</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby Proficient in OOP, SQL, Design Patterns</li><li>Experience with data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer  - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535","applyUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897603986,"descriptionPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"96562e50-0bf7-4a14-a910-4ef63f16d451","lists":[{"text":"What You Will Do","content":"<li>Build large-scale and high-performance services to develop simple, easy-to-use products for our unique end customers</li><li>Design and develop a highly maintainable and reliable Android app</li><li>Write clean and tested code, mostly in Kotlin for Android native environment</li><li>Coordinate with other teams (Product Management, UX/Design, Backend Engineering, and Quality Engineering teams) on building and managing the Android app</li><li>Implement tech excellence in the Android development environment</li><li>Help in a constant exploration of new technology and tools</li><li>Deliver solutions that bring a positive impact to low-income communities through up-to-date software technologies</li><li>Going forward, you will have to work on flutter application as well</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience in software engineering</li><li>Strong knowledge of Kotlin, Android tools and framework, and Android Studio</li><li>Good skill in unit tests. Plus points for UI tests</li><li>Experience in using app vitals and performance monitoring systems</li><li>Experience building an end-to-end system, preferably for a large user base</li><li>Strong attention to detail, particularly on software engineering fundamentals, testing methodologies, and quality</li><li>Familiarity with Android design patterns</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - Android (Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451","applyUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451/apply"},{"additionalPlain":"About the Team\n\nThe Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).\n\nOne of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.\n\nOff hours, you’d probably find us hang out, dinner together or playing games\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).</div><div><br></div><div>One of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.</div><div><br></div><div>Off hours, you’d probably find us hang out, dinner together or playing games</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697610584742,"descriptionPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","id":"cd554abc-dc06-4177-be50-ccbc638fd6d9","lists":[{"text":"What You Will Do","content":"<li>Work closely with team lead to deliver product features that enable efficient handling of queries for our internal users (customer service agents) and complaints raised by external users (customer, driver, and merchant)</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems</li><li>Write code that’s clear, concise, performant, tested and easily understood by others</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Writing technical documents and providing technical training for end users if necessary</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2-3+ years of hands-on experience in designing, developing, testing, and deploying applications on Go-Lang, Clojure, Java, Ruby, or OOPL large-scale applications</li><li>In-depth experience&nbsp;of at least one programming language and framework, deep understanding of SQL databases, Linux, Kafka, Redis, and RabbitMQ</li><li>Proficient in OOP, SQL, Design Patterns Data modeling experience in Relational databases</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate risks</li>"}],"text":"Software Engineer - Customer Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9","applyUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><span style=\"font-size: 16px\"><b>About the Team</b></span></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897318094,"descriptionPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><span style=\"font-size: 16px\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"4439eb62-6f08-444b-946d-1dff07d7d0d3","lists":[{"text":"What You Will Do","content":"<li>Working on mobile applications iOS and going forward you will work on flutter application</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, communicate project/development status to internal and external teams in a timely fashion</li><li>Participating in the design review process, seeking and providing constructive criticism</li><li>Improving code structure and architecture in service of testability and maintainability</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentations of how their design and architecture evolves over time</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>2-4 years of experience with iOS development</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in Swift programming, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Understanding of iOS Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third party libraries for networking, async, image loading etc</li><li>Good analytical and problem solving skills</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - iOS ( Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3","applyUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3/apply"},{"additionalPlain":"About the Team\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716980506841,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","id":"930cfb6b-99e3-4334-bc10-3fac18f8eff0","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Helping out in onboarding process by sharing contexts and pairing with new member of the team</li><li>Start mentoring or guiding SE1</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years relevant software development experience through internship stint and/or college projects</li><li>Proficient in Kotlin programming, Java and the Android APIs. </li><li>Strong knowledge in Android Apps architecture and implementationAbility to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular libraries for networking, async, image loading etc.</li><li>Well-versed with Agile methodologies, TDD and Test Engineering and Automation.</li>"}],"text":"Software Engineer (Android) - Gofood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0","applyUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0/apply"},{"additionalPlain":"About the Team\n\nMerchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nOur team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Merchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>Our team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Merchant Lending","allLocations":["Jakarta"]},"createdAt":1721735169268,"descriptionPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","id":"dab778da-b4eb-4e7e-bc8e-997af7210d52","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain user-facing features, translating designs and requirements into well-designed, testable and efficient code</li><li>Collaborate with other team members and stakeholders to deliver high-quality software solutions</li><li>Troubleshooting and debugging to optimize performance.</li><li>Be proactive, ask questions, and be an active member of the team striving towards improving the merchant experience&nbsp;</li><li>Learn new technologies to keep yourself updated and brainstorm with the managers about using the new technologies in day-to-day problem-solving</li>"},{"text":"What You Will Need","content":"<li>Degree/Diploma in Computer Science, Engineering, or related field.</li><li>2+ years of experience in developing using Java</li><li>Understand programming practices such as separation of concerns, unit testing, and writing self-documenting code</li><li>Familiarity with mainstream frameworks like Spring, Spring Boot, and Linux operating systems, understanding of database principles, and proficiency in using databases like MySQL or PostgreSQL.</li><li>Familiarity with front-end related technologies and concepts such as Javascript/Typescript, CSS, HTML, DOM, network protocol, and mainstream front-end frameworks</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (Back End) - Merchant Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52","applyUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713521223842,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"331177df-4294-4bc1-93a4-6459ff18ef97","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97","applyUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899384459,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"c0e92e19-ce60-4cfc-a58b-553f17452483","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483","applyUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483/apply"},{"additionalPlain":"About the Team\n\nConsumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1714016329286,"descriptionPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","id":"88358de8-e37b-4bd6-9afe-359eea3128b9","lists":[{"text":"What You Will Do","content":"<li>Own feature development from end-to-end, constantly pair with junior engineers, and improve them.</li><li>Write code that's clear, concise, performant, tested, and easy to understand by other teams and engineers.</li><li>Contribute to the design and development of highly scalable, available, reliable, secure, and fault-tolerant services.</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices.</li><li>Deep dive and debug production issues across services and levels of the stack when needed.</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently.</li>"},{"text":"What You Will Need","content":"<li>Passion for software development</li><li>At least 3 years of relevant software development experience with consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Ability to learn or use Java, Kotlin, and JS, proficiency in at least one of them</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, database consistency and transactionality, asynchronous programming, fault tolerance and monitoring, performance, feature flags, and backward compatibility&nbsp;</li><li>Understanding of a mobile application’s interaction with the back-end and other systems</li><li>Deep understanding of relational databases; ability to design performant, easy-to-understand architectures, and know-how for applying changes with no downtime to production systems</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, AWS, GCP</li>"}],"text":"Software Engineer (Full Stack) - BNPL","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","descriptionBodyPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9","applyUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9/apply"},{"additionalPlain":" About the team\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div>&nbsp;<span style=\"font-size: 16px\">About the team</span></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899689491,"descriptionPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","id":"89a62415-b145-4593-ac20-b82ec0ccfacb","lists":[{"text":"What You Will Do","content":"<li>Solve technical problems and build the next generation of products for our consumers</li><li>Spike new technologies and find a viable way to improve customers experience</li><li>Improve the testability and maintainability of the code</li><li>Build reusable iOS software components for interfacing with multiple applications</li><li>Improve and stabilize IOS sdks used by number of internal and external clients</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>At Least 2 years of full-time iOS engineering experience</li><li>Experience developing, maintaining, and innovating large scale, consumer mobile application</li><li>Predictability and balance of product delivery speed and quality</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in <b>Swift programming</b>, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Working experience with popular libraries for networking, async, image loading, etc</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><li>Experience and knowledge of writing testable and high-quality code</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (iOS) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","descriptionBodyPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb","applyUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb/apply"},{"additionalPlain":"About the Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</div><div><br></div><div>Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</div><div><br></div><div>As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).</div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1719909295384,"descriptionPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","description":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","id":"1a190954-9482-4953-a750-f2ae33a50003","lists":[{"text":"What You Will Do","content":"<li>Develop and Test: Write, test, and maintain software across our platforms, ensuring robustness and scalability.</li><li>Collaborate: Work closely with senior engineers and cross-functional teams including Backend, Frontend, Mobile, and QA to design and execute solutions.</li><li>Learn and Grow: Receive mentorship from senior engineers, enhancing your understanding of software development processes and best practices.</li><li>Contribute: Play a key role in the development and optimization of new features and systems within Midtrans.</li>"},{"text":"What You Will Need","content":"<li>Currently enrolled in or recently graduated with a degree in Computer Science, Software Engineering, or a related field.</li><li>Strong foundational knowledge in at least one programming language (Java, Python, JavaScript, etc.).</li><li>Understanding of basic software development concepts and methodologies.</li><li>Familiarity with version control systems, preferably Git.</li><li>Problem-Solving: Ability to think critically and solve complex problems.</li><li>Communication: Excellent verbal and written communication skills.</li><li>Teamwork: Eagerness to work within a team-oriented environment.</li><li>Adaptability: Openness to learning new technologies and methodologies.</li>"}],"text":"Software Engineer Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","descriptionBodyPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003","applyUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003/apply"},{"additionalPlain":"About the Team\n\nThe Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">The Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721305380078,"descriptionPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","id":"75c0d634-b28a-4f10-8f5a-efacb32b6444","lists":[{"text":"What You Will Do","content":"<li>Collaborate with product engineers to unify and optimize build standards across Android apps</li><li>Enhance build performance and streamline development processes</li><li>Identify and resolve bottlenecks in the current build system.Forecast and future-proof Android platform engineering services</li><li>Implement best engineering practices and ensure adherence across product groups</li><li>Conduct thorough code reviews and provide constructive feedback</li><li>Mentor junior engineers and support their professional growth</li><li>Participate in architectural design reviews and contribute to technical decision-making</li>"},{"text":"What You Will Need","content":"<li>5+ years of mobile engineering experience with Android as primary expertise</li><li>Proficiency in writing clear, concise, and maintainable code</li><li>Experience with collaborating on projects involving multiple teams</li><li>Strong understanding of mobile app architecture, testing, and performance optimization</li><li>Passion for building scalable and reusable systems</li><li>Ability to make informed decisions in architectural design reviews</li><li>Experience with build systems and CI/CD pipelines</li><li>Familiarity with Flutter or a willingness to learn it</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Sr. Software Engineer (Android) - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444","applyUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444/apply"},{"additionalPlain":"About the Team\n\nOur Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nTransport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)  using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Transport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)&nbsp; using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717676182978,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","id":"22ac4805-bcbe-4698-9e51-cb25754ac244","lists":[{"text":"What You Will Do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Actively mentor SE/ASEs&nbsp; in the team</li><li>Translate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environments</li><li>Improve engineering standards, tooling and processes</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applications</li><li>Have expertise in at least one of Go or Java</li><li>In-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etc</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"Sr. Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244","applyUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks\n\nYou get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks</span></div><div><br></div><div><span style=\"font-size: 16px\">You get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Jakarta"]},"createdAt":1713436041495,"descriptionPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","id":"e2bbb29c-85ef-4db2-9ea7-93af9101b634","lists":[{"text":"What You Will Do","content":"<li>Automate mechanism to make sure app performance adheres to the standards set internally</li><li>Building tools that would alleviate mobile engineer's development experience and productivity&nbsp;</li><li>Build dashboard and alerting system around mobile app performance (using tools like Firebase, Instabug, etc)</li><li>Foster a development culture that focuses on the quality of delivery</li><li>Creating and maintaining SDKs like networking, logging, etc. These sdk’s are responsible for providing common solutions to products across all iOS mobile teams</li><li>Continuously discover, evaluate, and implement new technologies to maximize development efficiency</li><li>Create excellent, clear, and insightful documentation ex: guidelines, best practices, how-to, FAQs etc</li>"},{"text":"What You Will Need","content":"<li>Atleast 3+ years of mobile engineering experience with iOS as primary expertise</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Ability to can take (or pitch) technical decisions, own it and raise impediments early if needed</li><li>You are very well versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>You have a passion for building scalable and composable systems that would last long</li><li>You are a hands-on engineer with a focus on writing easy to read code than over-engineering</li><li>You are a great communicator who can express your ideas clearly and build consensus to push technical agendas</li>"}],"text":"Sr. Software Engineer (iOS) - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634","applyUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634/apply"},{"additionalPlain":"About the Team\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\n\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</span></div><div><br></div><div><span style=\"font-size: 16px\">We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717559195275,"descriptionPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","id":"8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","lists":[{"text":"What You Will Do","content":"<li>Help provide clarity and direction for marketing campaigns or initiatives</li><li>To become the bridge between the Creatives and the marketing, media, social, design, product and research team</li><li>Always bringing the consumer perspective into the creative process in Gojek by simply staying in touch with society and the trends that are changing it</li>"},{"text":"What You Will Need","content":"<li>You have at least 5 years of strategy experience in an agency or related environment</li><li>Ability to deliver a clear, insight-based strategic recommendation in the form of a written brief</li><li>Ability to support Creatives and Designers&nbsp; with relevant stimulus, routes, or advice</li><li>Ability to visualize simple customer journeys in clear &amp; compelling ways</li>"}],"text":"Strategic Planner - Creative Labs - #10088","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px;\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","descriptionBodyPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","applyUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713867338946,"description":"","descriptionPlain":"","id":"afb5bc40-aa4f-4837-a2d9-7d38eade2599","lists":[{"text":"What will you do","content":"<li>Assume ownership of key performance indicators (KPIs) driving revenue and profitability for Consumer Lending <a href=\"http://business.Develop\" class=\"postings-link\">business.</a></li><li><a href=\"http://business.Develop\" class=\"postings-link\">Develop</a> comprehensive strategies and roadmaps to achieve growth objectives through a combination of <a href=\"http://initiatives.Identify\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Identify\" class=\"postings-link\">Identify</a> growth opportunities within the consumer lending business by analyzing business data, transactional data, customer activity within platforms, and leveraging customer <a href=\"http://insights.Lead\" class=\"postings-link\">insights.</a></li><li><a href=\"http://insights.Lead\" class=\"postings-link\">Lead</a> the prioritization process, strategizing, and focusing on solutions aimed at addressing user needs and enhancing user <a href=\"http://experience.Validate\" class=\"postings-link\">experience.</a></li><li><a href=\"http://experience.Validate\" class=\"postings-link\">Validate</a> business strategies and hypotheses through rigorous experimentation and statistical <a href=\"http://methodologies.Present\" class=\"postings-link\">methodologies.</a></li><li><a href=\"http://methodologies.Present\" class=\"postings-link\">Present</a> findings and insights to senior management to inform strategic decision-making regarding feature prioritization and impact <a href=\"http://analysis.Cultivate\" class=\"postings-link\">analysis. </a></li><li><a href=\"http://analysis.Cultivate\" class=\"postings-link\">Cultivate</a> and manage partnerships with external stakeholders.</li>"},{"text":"What will you need","content":"<li>BS/MS in Business, Engineering, Computer Science, Math, Economics, Statistics, or <a href=\"http://equivalent.8-10\" class=\"postings-link\">equivalent.</a></li><li><a href=\"http://equivalent.8-10\" class=\"postings-link\">8-10</a> years of working experience with strong business <a href=\"http://acumen.End\" class=\"postings-link\">acumen.</a></li><li><a href=\"http://acumen.End\" class=\"postings-link\">End</a> to end problem-solving mindset that can work in increments and <a href=\"http://exponents.Strong\" class=\"postings-link\">exponents.</a></li><li><a href=\"http://exponents.Strong\" class=\"postings-link\">Strong</a> project management skills to manage complex projects, also can manage and prioritize multiple internal and external <a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">Proficiency</a> in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with good knowledge of SQL and experimentation processHustle is essential, moving quickly and executing to allow for continual iteration is a core competency of the teamExperience in a financial services and technology companies is preferred.</li>"}],"text":"Strategy Senior Manager, Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599","applyUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599/apply"},{"additionalPlain":"Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1709264557847,"descriptionPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","description":"<div><span style=\"font-size: 10pt\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","id":"eaab5bee-084d-4cdc-bd08-63230251009c","lists":[{"text":"What you will do","content":"<li>Develop and maintain supply related dashboards to monitor key metrics and compare achievements against targeted <a href=\"http://goals.Analyze\" class=\"postings-link\">goals.</a></li><li><a href=\"http://goals.Analyze\" class=\"postings-link\">Analyze</a> various data points, detect anomalies and spot trends to drive business and strategic decision-making on supply <a href=\"http://initiatives.Collaborate\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Collaborate\" class=\"postings-link\">Collaborate</a> with the BI, Data Science, Marketing, and Product Management teams to ensure alignment on data analysis, methodologies, insights, and recommendations and proactively escalate issues to relevant <a href=\"http://stakeholders.Analysis\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Analysis\" class=\"postings-link\">Analysis</a> on the competitive intelligence insights and <a href=\"http://findings.Be\" class=\"postings-link\">findings.</a></li><li><a href=\"http://findings.Be\" class=\"postings-link\">Be</a> the go-to person on anything related to the supply health metrics and analysis.</li><div><br></div>"},{"text":"What you will need","content":"<li>A BS/MS in Business, Engineering, Computer Science, Mathematics, Economics or equivalent experience</li><li>3+ years of experience within one or more of the following fields: Business Analytics, Strategy and Planning, Growth or relevant functions</li><li>Comfortable analyzing large amounts of raw data with an obsession to detail and accuracy of data</li><li>Able to uncover the story and relationship behind the numbers and communicate the insights to a wider audience</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Proficiency in multiple analytic, database, and visualization tools (e.g., Tableau, Looker Studio, etc.) along with strong knowledge of SQL</li><li>A scientific and hypothesis-driven thinking process with the ability to work in increments and exponents</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders </li><div><br></div>"}],"text":"Supply Strategy Data Analyst [Ads]","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","descriptionBodyPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c","applyUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c/apply"},{"additionalPlain":"About the team \n\nWe are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.\n\n","additional":"<div><b>About the team</b>&nbsp;</div><div><br></div><div>We are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - ESG","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721114762245,"descriptionPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","id":"1a303596-73f9-4d05-85f9-73cd361f03ef","lists":[{"text":"What you will do","content":"<li>Leading GoTo Group’s sustainability commitments and related workstreams, focusing on the company's environmental and socio-economic impact and financial inclusion of the ecosystem.</li><li>Overseeing Zero Barriers as a socio-economic pillar, focusing on the development of in-house financial products and services aimed at improving the economic well-being and sustainable livelihoods of GoTo’s drivers and merchant partners.</li><li>Implementing impact measurement frameworks to transparently communicate social and economic benefits resulting from company initiatives, reinforcing accountability.&nbsp;</li><li>Driving the implementation of comprehensive Diversity, Equity, and Inclusion (DEI) policies within GoTo, to foster a culture of equality and respect organization-wide.&nbsp;</li><li>Ensuring proactive compliance with relevant environmental, social, and governance (ESG) regulations, surpassing standards to uphold ethical business practices.</li>"},{"text":"What you will need","content":"<li>Extensive experience in ESG strategy, preferably within the tech industry.&nbsp;Strong understanding of global and local sustainability regulations and standards. (GRI, POJK, MSCI, S&amp;P, etc.)</li><li>Proven track record in leading sustainability initiatives and integrating them into business operations.</li><li>Excellent stakeholder management and communication skills.&nbsp;</li><li>Ability to analyze complex data and translate it into actionable strategies.&nbsp;Innovative thinking and problem-solving abilities.&nbsp;</li><li>Leadership skills with the ability to drive cultural change and motivate teams.&nbsp;</li><li>Proficiency in project management and sustainability reporting tools.</li>"}],"text":"Sustainability Senior Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef","applyUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720377852482,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically-oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.</li>"}],"text":"Technical Program Manager - Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","applyUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720689871979,"descriptionPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","id":"bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Support Head in establishing and strengthening relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors</li><li>Project Leadership: Support multiple projects in partnership with government institutions, focusing on Transport and Mobility technology.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances</li><li>Project Management: Support public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government</li><li>Established network among government stakeholder with a proven impact on policy decisions</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Transport and Mobility PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","descriptionBodyPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","applyUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705901801143,"descriptionPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","description":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","id":"17408b81-f5a0-4f15-afae-cc04ed7e43b6","lists":[{"text":"What You Will Do","content":"<li>Prepare Risk reporting and position reporting</li><li>Conduct assessments to define and analyze possible risks</li><li>Evaluate the gravity of each risk by considering its consequences</li><li>Design processes to eliminate or mitigate potential risks</li><li>Evaluate existing policies and procedures to find weaknesses</li><li>Prepare reports and present recommendations</li><li>Ensure risk exposures of the company is within stipulated limits</li><li>Work closely with other business stakeholders</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years&nbsp;</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal and external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL will be an advantage</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Underwriting and Credit Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","descriptionBodyPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6","applyUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6/apply"},{"additionalPlain":"About The Team\nMerchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Merchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721636128423,"descriptionPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","id":"a007af4b-690d-4487-874d-f04ce3f62ce0","lists":[{"text":"What You Will Do","content":"<li>Maintain relationship with BPO vendor and regularly evaluate their productivity&nbsp;</li><li>Become a COE of merchant engagement framework for region team</li><li>Assisting SM Merchant Engagement in managing milestones, timeline, as well the stakeholders engagement related to the managed projects.</li><li>Develop and updating Key Insights and Analysis related to Unmanaged merchants performances</li>"},{"text":"What This Role Needs","content":"<li>At least 2 years experience in field sales or telemarketing, especially with a proven track record of managing local / regional business in reputable companies</li><li>Experienced in managing large business partner such as distributor or outsourcing vendor</li><li>Have experience in basic to intermediate data analytics skills</li><li>Having ability to turn insight into actionable plan</li><li>Strong business acumen with proven track record in stakeholder management</li>"}],"text":"Unmanaged Merchant Engagement Senior Associate - #10326","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","descriptionBodyPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0","applyUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119556899,"descriptionPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","id":"147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","lists":[{"text":"What you will do","content":"<li>Own the GoMart Growth Strategy and Promotion budgetTake charge of monthly budgeting and weekly execution with an emphasis on growth while maintaining profitability</li><li>Lead initiatives, strategies, and implementation, with a primary focus on the customer lifecycle funnel targeting the acquisition of new and churned users while growing retention of existing customers through a compelling offer.</li><li>Experiment with a combination of multiple initiatives (e.g. vouchers/promotion, product or pricing changes) to validate initiatives through statistical analysis</li><li>Use data across customer, driver, and merchant activity from multiple products to hypothesize potential solutions and test them in practice&nbsp;</li><li>Collaborate with Merchandising, Marketing, Product, and Operations teams in the development and implementation of initiatives and strategies</li><li>Prepare routine reports and present findings to leadership as the basis of rationale and recommendations for strategic decision-making</li>"},{"text":"What you will need","content":"<li>At least 5 years of experience in strategy or growth role at a tech company, e-commerce, or management consulting background</li><li>Strong proficiency in Microsoft Excel; Understanding of SQL and other statistical tools is a must.</li><li>Strong business acumen, an end-to-end problem-solving mindset with the ability to work in increments and exponents and balance attention to detail with swift execution</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"User Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","applyUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663/apply"}]
-  recorded_at: Mon, 29 Jul 2024 09:06:43 GMT
+        [{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721638994130,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","id":"f53cae40-f605-4215-9a82-b48c5db508b5","lists":[{"text":"What you will do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance.</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Actively mentor SE/ASEs&nbsp; in the teamTranslate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environmentsImprove engineering standards, tooling and processes</li>"},{"text":"What you will need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applicationsHave expertise in at least one of Go or JavaIn-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etcExcellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"#10010 Senior Backend Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5","applyUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5/apply"},{"additionalPlain":"The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.\nThe Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.\nWe, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.\n","additional":"<div><span style=\"font-size: 10pt\">The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 10pt\">The Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.</span></div><div><span style=\"font-size: 10pt\">We, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721640901865,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","id":"ce351965-e2f9-4f8f-8cad-38fb4cd045e9","lists":[{"text":"What you will do","content":"<li>Independently responsible for the entire lifecycle of high-complexity Android projects or features including software design, development, and deployment within their team</li><li>Planning &amp; timely delivery of work within their teamImproving code structure and architecture in service of testability and maintainability</li><li>Writing, co-writing, and reviewing design documentation</li><li>Leading new language/framework POCsParticipating in the design review process, seeking and providing constructive criticism</li><li>Tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Ensuring that their team has strong sets of documentation and journals of how their design and architecture evolve over time</li><li>Ensuring predictability, quality &amp; throughput of their team's delivery</li><li>Prioritizing and valuing work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalating challenges that are outside their control but affect the team's delivery</li><li>Prioritizing work based on understanding the trade-off between quality, tech-debt, and delivery</li><li>Leading effort to work with other teams to solve problems affecting the delivery of their team</li><li>Participating in prioritization of cross teams initiatives &amp; leading those within their own team</li><li>Splitting complex engineering task into smaller components which can be developed by junior engineers in the team</li><li>Mentoring other engineers on an individual basis</li><li>Participating in the hiring process (by meeting candidates, and attending recruiting events)</li><li>Conducting engineering interviews</li>"},{"text":"What you will need","content":"<li>Should have at least 4 years of experience with Android developmentProficient in Kotlin programming, Java, and Android APIs.</li><li>Strong knowledge of Android Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standards across the teamWorking experience with popular libraries for networking, async, image loading, etc.</li><li>Well-versed with Agile methodologies, TDD, and Test Engineering &amp; Automation.</li><li><b>Bonus points if:&nbsp;</b>Have experience in Running A/B or multi-variant experiments for features that you built.</li>"}],"text":"#10279 Senior Android Developer (Logistic)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9","applyUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898011592,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"657d7112-420a-4e42-8bfd-1b790fc05155","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"#10357 Senior Software Engineer - Go-food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155","applyUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721901545426,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"87b4d0e4-219e-4ba7-9433-27220623ab69","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10358 Software Engineer - Backend (Groceries)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69","applyUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898703682,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10359 Software Engineer - Backend","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","applyUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</div>","categories":{"department":"ODS - Regions","location":"Bali","team":"East Java, Bali, Nusra Regions","allLocations":["Bali"]},"createdAt":1720778770433,"descriptionPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"73172a46-5486-4860-a256-8e17225c4a47","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transaction</li><li>Create regular report to what's happen in their respective areas toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Fresh Graduate are welcome to Apply&nbsp;</li><li>2 years relevant experience with preferable industries: top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region will be a plus</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Bali)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47","applyUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721704703939,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"885b2af9-c94a-4010-b0c4-c6ea7812039b","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b","applyUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721037961422,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"94efd0c8-e79b-41e1-aa37-a7a4c08c108f","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f","applyUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f/apply"},{"additionalPlain":"About the team\n\nOur GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n","additional":"<div><b>About the team</b></div><div><br></div><div>Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</div><div><br></div><div>Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</div>","categories":{"department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721623842937,"descriptionPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","id":"94f85d13-6fe6-43a8-96c8-4898ab75d908","lists":[{"text":"What Will You Do","content":"<li>Executing campaign creation of our merchants through our inhouse portal and assist in troubleshooting to our product managers and engineers&nbsp;</li><li>Proactively improve the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Learn to introduce beneficial business changes through well-written document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Support and coordinate with multiple stakeholders to ensure seamless workflow, update relevant changes and address any operational issues</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resources</li>"},{"text":"What Will You Need","content":"<li>Minimum 1 year of working experience&nbsp;</li><li>End to end the problem-solving mindset that can work well with stakeholders&nbsp;</li><li>Basic data analytics capability, having capability in SQL is a plus</li><li>Experience in Growth, Product Management, and Data team is a plus</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders&nbsp;</li><li>Open to acquiring new skills and taking on diverse projects</li>"}],"text":"Ads Ops Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","descriptionBodyPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908","applyUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908/apply"},{"additionalPlain":"About The Team\nArea CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales & analytics team) in the designated Areas.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Area CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales &amp; analytics team) in the designated Areas.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Semarang","team":"Central West Java Regions","allLocations":["Semarang"]},"createdAt":1720592465974,"descriptionPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","id":"f1bdce17-4ab5-49ab-9dbc-6d96a5619846","lists":[{"text":"What You Will Do","content":"<li>Support Area Head to drive consumer engagement focus areas in terms of Visibility &amp; Partnership which will deliver POI domination, POS merchants branding, standard package that will deliver Area target completed orders and active users</li><li>Managing all day to day marketing executional activities from all areas needed to deliver the consumer engagement plans. e.g. contract, PO, invoice, etc.</li><li>Ensure all consumer engagement activities in areas are delivered with a given standard of accuracy, completeness, timeliness as per the standard package and local initiatives</li><li>Externally supervise vendors/daily workers in executing merchant branding and POI domination on a regular basis</li><li>&nbsp;Internally work with direct responsibility to deliver area executions and targets by executing events, exhibits, and other activities</li><li>Good with data to develop and execute clear integrated strategies of digital marketing with clear metrics and excellent results</li><li>Responsible for setting the integrated communications plan and ensuring consistency of messaging and brand communications. Working closely with the sales, government relations, and operations team</li>"},{"text":"What This Role Needs","content":"<li>At least 2&nbsp; years of working experience in Marketing/Sales</li><li>Good understanding of local knowledge</li><li>Strong analytical and planning skills</li><li>Good communication and presentation skills</li><li>Excellent problem-solving skill with the ability to play it well independently and in a team</li><li>Good collaboration with compassion and proactiveness</li><li>Agile and fast in thinking and execution</li><li>Have exposure of working at a top global FMCG company would be a plus point</li>"}],"text":"Area CE Associate - Semarang - #10227","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","descriptionBodyPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846","applyUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720169838701,"descriptionPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><span style=\"font-size: 10pt\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","lists":[{"text":"What you will do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;</li><li>driver acquisition management</li><li>driver engagement management (loyalty &amp; retention and safety &amp; performance training)&nbsp;</li><li>driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant)</li><li>driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li><div><br></div>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Having good understanding about supply and demand planning</li><li>Having experience in managing a small team (&gt; 3 members)</li><li>Having good communication skills and good attention to detail and routine activities</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Able to handle communication in community or mass conflict&nbsp;</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written in English</li>"}],"text":"Area Operations Manager - Bekasi","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","applyUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb/apply"},{"additionalPlain":"About the team \n\nArea Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the team </b></div><div><br></div><div><span style=\"font-size: 16px\">Area Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Depok","team":"-","allLocations":["Depok","Bogor"]},"createdAt":1713768982209,"descriptionPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"18674f77-24b2-46a4-86bb-7b5e7fe71f2c","lists":[{"text":"What You Will Do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;Driver acquisition management, Driver engagement management (loyalty &amp; retention and safety &amp; performance training), Driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant), driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li>"},{"text":"What You Will Need","content":"<li>At least 5 years experience in operations/ supply/ demand generation, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Good understanding about supply and demand planning</li><li>Prior experience in managing team (&gt; 3 members)</li><li>Good communication skills and good attention to detail and routine activities</li><li>Ability to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Capability to handle communication in community or mass conflict&nbsp;</li><li>Proficiency in English both spoken and written</li>"}],"text":"Area Operations Manager (Bogor Depok)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c","applyUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c/apply"},{"additionalPlain":"About The Team\n\nOur Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners. \n\nOne of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team. \n\nOur team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">One of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"-","allLocations":["Tangerang"]},"createdAt":1716869065162,"descriptionPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","id":"8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","lists":[{"text":"What You Will Do","content":"<li>List, identify, and propose solutions to our driver partners' problems on the field and ensure their concerns are heard by following up with them</li><li>Manage offline engagement (i.e. 'kopdar') as our way to inform, reach, and engage with driver partners</li><li>Ensure all engagement programs are well executed and implemented</li><li>Handle driver support unit according to agreed operating office hours</li><li>Support implementation of Gojek's policies/programs by managing these changes</li><li>Propose activities/programs to engage our driver partners</li><li>Monitor personal metrics of engagement with driver partners, and propose solutions to increase the level of engagement</li>"},{"text":"What You Will Need","content":"<li>A Bachelor's degree (fresh graduates are welcome to apply!)</li><li>At least 1 year of experience in supply chain, preferably at a multinational company</li><li>Strong analytical thinking and problem-solving skills to effectively resolve driver-related issues</li><li>Strong interpersonal skills in order to cater and build relationships with various stakeholders</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Sharp attention to detail to increase productivity and reduce the likelihood of errors</li><li>Excellent planning and organizational abilities to ensure the area team is on track to achieve its goals</li><li>An understanding about/familiarity with the Tangerang region</li>"}],"text":"Area Operations Staff","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","descriptionBodyPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","applyUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2/apply"},{"additional":"","additionalPlain":"","categories":{"department":"ODS - Regions","location":"Balikpapan","team":"Emerging Market","allLocations":["Balikpapan"]},"createdAt":1719223321521,"description":"","descriptionPlain":"","id":"95ee9a06-a46d-43a2-a8e7-003de776404d","lists":[{"text":"What you will do:","content":"<li>Handle all the driver community, marketing, and driver care responsibilities on areas level and channel walk in center on each area;</li><li>Ensure problem solving according to agreed process &amp; based on standard operational procedure;</li><li>Manage driver’s problems and empowerment;</li><li>Coordinate with Area Operations Manager for day-to-day escalated issues around driver service and customer service to manage service time, driver and customer satisfaction;</li><li>Developing the marketing strategy for the company in line with company objectives;</li><li>Conceptualizes events, exhibits and other below the line marketing based on the marketing plan, and evaluate the effectiveness of all marketing activities;</li><li>Maintain effective internal communications to ensure that all relevant company functions are kept informed of marketing objectives.</li>"},{"text":"What you will need:","content":"<li>Having a minimum of 3 years experience in related fields;</li><li>Bachelor degree from top university any well-known universities from each region with GPA &gt; 3.2 or equivalent;</li><li>Passionate about community development, having relevant previous experience would be preferred;</li><li>Experience launching community initiatives (building an online forum, launching an ambassador program, creating an event series, etc.);</li><li>Ability to identify and track relevant community and market metrics;</li><li>Excellent verbal communication and writing skills;</li><li>Having a basic of data analytics;</li><li>Willing to relocate to a selected area.</li>"}],"text":"Area Operations Supervisor - Balikpapan","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d","applyUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d/apply"},{"additionalPlain":"About the team\n\nThis position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team. \n","additional":"<div><b>About the team</b></div><div><br></div><div>This position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team.&nbsp;</div>","categories":{"department":"ODS - Regions","location":"Makassar","team":"Emerging Market","allLocations":["Makassar"]},"createdAt":1721716492787,"descriptionPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","description":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","id":"20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","lists":[{"text":"What Will You Do","content":"<li>Develop and implement procedures for effective sales support administration;</li><li>Monitor and analyze sales support team performance to identify areas for improvement and implement strategies to increase efficiency;</li><li>Ensure all sales inquiries and issues are addressed promptly and accurately, with a focus on improving merchant satisfaction &amp; topline sales metrics;</li><li>Coordinate with the merchant sales team to streamline sales processes and remove obstacles in the sales cycle;</li><li>Execute GoFood onboarding timely &amp; ensure that there is no backlog</li><li>Able to understand KYC follow up reasons based on FAQ and able to know when to escalate</li><li>Collaborate with other departments to ensure sales and marketing strategies are aligned and support the overall goals of the organization;</li><li>Assist in the development and implementation of sales policies and practices that drive sales effectiveness.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree in Business Administration, Marketing, or a related field;</li><li>Minimum of 3 years of experience in sales support, account management, customer service, sales-marketing administration related or a supervisory role within a sales-focused organization;</li><li>Strong customer/merchant partner focus and project management skills preferred;</li><li>Has data reporting skills, preferred both Bahasa Indonesia and English;</li><li>Strong analytical and problem-solving abilities by utilizing e.g. Google Sheet, etc;</li><li>Detail and deadline oriented;</li><li>Strong stakeholder management and cross-functional collaboration;</li><li>Able to adapt in a fast-changed environment.</li>"}],"text":"Area Sales Support Supervisor (Sulampa)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","descriptionBodyPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","applyUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450/apply"},{"additionalPlain":"About The Team\n\nOur tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!  \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">Our tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!&nbsp;&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697204557563,"descriptionPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","description":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","id":"56966262-038f-497f-84c1-f360a9440c55","lists":[{"text":"What You Will Do","content":"<li>Manage tax compliance matters; including preparation of monthly and annual tax calculation/payment/returns, i.e. WHT, VAT, CIT)</li><li>Manage and advise day-to-day business initiatives including decisive actions toward dynamic business products</li><li>Manage and handle restructuring projects independently with supervision from the AVP of Tax</li><li>Able to communicate and align with relevant stakeholders within the group</li><li>Monitoring any tax regulation updates, identifying relevant business areas that may be impacted, and planning the risk mitigation strategy</li><li>Able to support the litigation process and assessment of risks</li><li>Able to support the advocacy initiatives within the relevant external organizations.</li>"},{"text":"What You Will Need","content":"<li>S1 Bachelor of Economics (majoring in accounting or corporate finance) or Bachelor of Social Finance (Majoring in Fiscal Administration) </li><li>Minimum 5 years of working experience in the taxation field</li><li>Strong interpersonal, analytical, communication, and presentation skills with advanced command of written and spoken English</li><li>Strong technical skills in tax, accounting, and corporate finance</li><li>Ability to work in a fast-paced, rapidly changing, and high-growth environment</li><li>Able to work independently and in a team</li>"}],"text":"Assistant Tax Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","descriptionBodyPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55","applyUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721353652294,"descriptionPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","description":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","id":"325ee617-30f3-41c1-a022-6577bd82faf0","lists":[{"text":"What You Will Do","content":"<li>Collecting and importing data from various sources into databases.</li><li>Cleaning and preprocessing data to ensure accuracy and consistency.</li><li>Analyzing datasets to identify trends, patterns, and insights.</li><li>Creating and maintaining data visualizations and dashboards.</li><li>Generating regular and ad-hoc reports for stakeholders.</li><li>Collaborating with team members and stakeholders to understand data needs and requirements.</li><li>Monitoring data quality and integrity, addressing any discrepancies.</li><li>Utilizing programming languages (e.g., SQL, Python) and tools (e.g., Sheet) for data manipulation and analysis.</li>"},{"text":"What You Will Need","content":"<li>Technical Skills: Proficiency in SQL, Python, and Sheet for data manipulation and analysis.</li><li>Analytical Skills: Strong analytical and problem-solving skills to interpret data and create actionable insights.</li><li>Reporting Tools: Familiarity with tools for generating reports, such as Sheet, Metabase, or Looker Studio.</li><li>Communication Skills: Ability to communicate findings and insights effectively to non-technical stakeholders..</li>"}],"text":"Business Analyst - GoPay","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt;\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt;\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","descriptionBodyPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0","applyUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716278898371,"descriptionPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","description":"<div><span style=\"font-size: 16px\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","id":"2242125a-7155-4353-bc79-473d237d6808","lists":[{"text":"What You WIll Do","content":"<li>Be the expert in using data to measure and analyze business performance.</li><li>Explore business issues/opportunities, uncover insights and/or identify targeted areas for business growth.</li><li>Lead new data analytics capability rollouts and/or data-led initiatives throughout organization.</li><li>Monitor key metrics and alert the business on potential issues.</li><li>Analyze operational efficiency and build business models to guide decision-making.</li><li>Design market/business intelligence reports and performance measurement dashboards to share with senior management.</li><li>Able to analyze business performance following the analysis framework.</li><li>Able to create reports/ dashboards individually.</li><li>Collaborates with business stakeholders to gather requirements and deliver actionable insights.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Statistics, Business Administration, or a related field.</li><li>2-5 years of experience in a BI or analytics role.</li><li>Proficiency in SQL and database management systems like MySQL, SQL Server, or Oracle.</li><li>Advanced knowledge of data modeling and data warehousing concepts.</li><li>Strong understanding of business processes and the ability to translate business requirements into technical solutions.</li><li>Familiarity with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Experience with BI reporting tools and dashboard development.</li><li>Proven ability to work with cross-functional teams and manage stakeholders.</li><li>Familiarity with business operations in the field.</li>"}],"text":"Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","descriptionBodyPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808","applyUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808/apply"},{"additionalPlain":"About The Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119647983,"descriptionPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><b style=\"font-size: 16px\">Job Scope</b></div><div><span style=\"font-size: 16px\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px\">6 Months Challenge</b></div><div><span style=\"font-size: 16px\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","id":"9a8977f6-ea32-40e0-bb09-d3330c40d056","lists":[{"text":"What You Will Do","content":"<li>Monitor performance metrics and adjust processes as needed</li><li>Build relationships with stakeholders to support process optimization initiatives</li><li>Leverage technology to automate tasks and improve accuracy</li><li>Focus on enhancing customer experience in building automated support processes</li><li>Ensure high-quality service delivery to customers</li><li>Implement changes to streamline workflows and enhance efficiency</li>"},{"text":"What This Role Needs","content":"<li>At least 5 years working experience in related field</li><li>Strong analytical and problem-solving skills</li><li>Experience in process optimization and workflow management</li><li>Proficiency with automation tools and technology</li><li>Excellent communication and coordination abilities</li><li>Ability to prioritize tasks and manage time effectively</li><li>Knowledge of customer experience best practices</li><li>Familiarity with fintech industry standards and trends</li><li>Collaborative mindset to build relationships with stakeholders</li>"}],"text":"Business Operations Analyst (Trust and Safety) - GoPay - #10311","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><b style=\"font-size: 16px;\">Job Scope</b></div><div><span style=\"font-size: 16px;\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px;\">6 Months Challenge</b></div><div><span style=\"font-size: 16px;\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","descriptionBodyPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056","applyUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264950378,"description":"","descriptionPlain":"","id":"73e71b86-d53f-4841-92ec-4bd09a0ef479","lists":[{"text":"What You Will Do","content":"<li>explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across the Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs..</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Data Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479","applyUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716265340466,"description":"","descriptionPlain":"","id":"36d71dff-c9ac-44b8-b870-f74d941bd7d3","lists":[{"text":"What You Will Do","content":"<li>Design and implement complex data solutions, architecting data systems, and driving technical initiatives.</li><li>Optimize data infrastructure for performance, scalability, and reliability - working with large-scale data volumes &amp; distributed systems.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Provide technical guidance and support to ensure the successful delivery of data projects, including troubleshooting and resolving technical challenges.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>5+ years of experience in data engineering, software engineering, or a similar role.</li><li>Expertise in programming languages such as Python, Java, or Scala.</li><li>Advanced knowledge of SQL, database management systems, and data warehousing concepts.</li><li>Extensive experience with big data technologies and distributed systems.</li><li>Proven track record of designing and implementing complex data pipelines and ETL processes.</li><li>Deep understanding of cloud-based data technologies and best practices.</li><li>Leadership abilities to mentor junior team members and lead technical initiatives.</li><li>Strong problem-solving and troubleshooting skills.</li><li>Ability to communicate technical concepts effectively to both technical and non-technical stakeholders.</li>"}],"text":"Data Engineer Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3","applyUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3/apply"},{"additionalPlain":"About the Team\n\nThe Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience. \nAs a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience.&nbsp;</div><div>As a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1717749466111,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","description":"<div><span style=\"font-size: 10pt\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","id":"d93a7524-8ab9-4499-9f04-0876fcafa529","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain performance management dashboards and visualizations.&nbsp;</li><li>Provide regular analysis on operational performance metrics including transactions, conversion rate, lead quality, cost efficiency, retention, and KPI tracking to guide decision-making and devise proactive solutions.&nbsp;</li><li>Collaborate across teams to drive Operational Excellence (OPEX) and Continuous Improvement Process (CIP) initiatives, identifying growth opportunities for product, customer, driver, and optimization.&nbsp;</li><li>Support senior management with clear and concise presentations of complex data sets for informed decision-making.&nbsp;</li><li>Build, automate, and enhance reporting, data logging, and data pipelines for availability, integrity, accuracy, and reliability, ensuring security and compliance.&nbsp;</li><li>Assist in report compilation, issue investigation, and liaison with internal and external stakeholders for regulatory compliance.</li>"},{"text":"What You Will Need","content":"<li>Bachelors' Degree in Economics, Computer Science, Engineering, Mathematics or Statistics.&nbsp;</li><li>Minimum 5 years experience with 3+ years of relevant experience in analytics and product/process improvement.&nbsp;</li><li>Proficient in analyzing large datasets and translating quantitative findings into actionable insights.&nbsp;</li><li>Excellent understanding of analytics, computational modeling, business needs analysis, data visualization, and stakeholder management.&nbsp;</li><li>Resilience and initiative in a fast-paced, dynamic environment&nbsp;</li><li>Proficient in SQL; experience in BI tools such as Tableau, Metaforce, Python or Looker is a plus&nbsp;</li><li>Prior experience demonstrating strong stakeholder engagement and vendor management skills is a plus</li>"}],"text":"Data Operations Analyst","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529","applyUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Internship","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719909376581,"descriptionPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","id":"816f2d4c-5ff6-4e83-8697-9c25df599409","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li><b>Fresh Graduates </b>from computer science, mathematics, or statistics<b>&nbsp;</b>(Students on final semester are also preferred)</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Data Scientist Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409","applyUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409/apply"},{"additionalPlain":"Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.\n","additional":"<div><span style=\"font-size: 10pt\">Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718963848611,"descriptionPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","description":"<div><span style=\"font-size: 9pt\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","id":"5d07cd21-8826-4de7-9ad4-15909a0c5c37","lists":[{"text":"What you will do","content":"<li>Devise and implement tailored digital marketing strategies for GoRide, GoCar, GoSend, and GoShop</li><li>Analyze market trends to identify growth opportunities and refine strategies accordingly</li><li>Collaborate cross-functionally to ensure alignment with business goals</li><li>Monitor and evaluate campaign performance to drive optimization</li><li>Stay updated on industry trends and technologies to drive innovation</li><li>Manage relationships with external partners and agencies to support initiatives</li><li>Contribute to overarching marketing strategies and brainstorming sessions.</li><div><br></div>"},{"text":"What you will need","content":"<li>3+ years of digital marketing experience</li><li>Proficiency in digital marketing tools and platforms such as Google Adwords, Meta, TikTok Ads, Google Analytics &amp; Data Studio/Looker</li><li>Strong analytical, communication, and problem-solving skills</li><li>Bachelor's degree in Marketing, Communications, or related field</li><li>Fluency in English. </li><div><br></div>"}],"text":"Digital Marketing Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","descriptionBodyPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37","applyUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37/apply"},{"additionalPlain":"The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1722240835278,"descriptionPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","description":"<div><span style=\"font-size: 9pt\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","id":"eb38692a-8133-4cd2-a793-f5d75ee8841a","lists":[{"text":"What You Will Do","content":"<li>Accountable for leading the driver onboarding and support team, ensuring a quick and seamless experience for driver-partners at the GoHub</li><li>Management of day-to-day operations of the team, including communications and KPI performance management</li><li>Drive results through strong internal and external collaboration to improve the quality and efficiency of the team</li><li>Support &amp; drive operational requirements, to achieve and exceed team productivity and service level targets</li><li>Responsible for the design, deployment and maintenance of processes arising from new product launches and enhancement to existing process flows</li><li>Understand reporting needs and provide appropriate data analysis on performance metrics for stakeholders</li><li>Work with relevant stakeholders to identify and prioritize improvement initiatives and other cross-functional projects</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience as an operations manager in a contact center / frontline customer service operations</li><li>Experience in managing teams, motivating, coaching and inspiring team members to achieve excellent customer experience</li><li>Address conflicts and interpersonal issues within the team professionally and diplomatically</li><li>Ability to make informed decisions under pressure, considering both short-term and long-term implications</li><li>Keen eye for detailed process steps &amp; identification of gaps/opportunities</li><li>Strong stakeholder and project management capabilities</li><li>Efficiently manage time, resources, and priorities to ensure productivity and meet deadlines</li><li>Keep customer needs in mind when making decisions and managing operations</li><div><br></div>"}],"text":"Driver Care Lead, Hub Operations","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","descriptionBodyPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a","applyUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a/apply"},{"additionalPlain":"About the Team\n\nWe are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nAlong with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1714628452648,"descriptionPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px\">&nbsp;</span></div><div><span style=\"font-size: 16px\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","id":"dfe98505-36d8-4467-aa36-df8599ab69d8","lists":[{"text":"What You Will Do","content":"<li>Assess and manage team performance through staff meetings, one on ones, and quarterly assessments</li><li>Mentor your engineers to ensure their growth and engagement in the team, evaluate team workload and develop a staffing plan, and assign projects and balance workload to ensure continuous delivery and higher predictability</li><li>Serve as primary interface to staffing team, creating job descriptions, identifying sources for candidates, conducting interviews and shepherding candidates through the process</li><li>Lead a team of Software Engineers focused on improving velocity and impact across Gojek’s diverse project areas and platforms</li><li>Become a partner to Product Managers on deciding vision, strategy and OKRs</li><li>Provide technical expertise throughout the product life cycle including design, implementation, and delivery of scalable build/test/release infrastructure</li>"},{"text":"What You Will Need","content":"<li>Having at least 8 years of relevant software development experience preferably with experience in data products, also at least 2 years of leading and mentoring an engineering team to success</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, TDD and Test Engineering, and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate dependency risks</li><li>Ability to review the code and ensure code maintainability as part of new product enhancements.</li>"},{"text":"Bonus Points If","content":"<li>Understanding in data modeling for data warehouse, relational database, and non-relational database</li><li>Understanding in batch and stream data pipeline; Beam, Flink, Spark</li>"}],"text":"Engineering Manager - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px;\">&nbsp;</span></div><div><span style=\"font-size: 16px;\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8","applyUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8/apply"},{"additionalPlain":"About the Team\n\nThe Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721370013113,"descriptionPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","id":"178ba514-705f-4f0b-9e48-fe917c47a95b","lists":[{"text":"What You Will Do","content":"<li>Continuously monitor, review, maintain, and improve security controls that are used to secure GoTo enterprise IT systems and SaaS services;</li><li>Review and implement initiatives to improve the security posture of GoTo enterprise IT systems and SaaS services;</li><li>Perform security hardening on GoTo IT systems and SaaS services;</li><li>Support the remediation of relevant security issues relevant to GoTo corporate IT systems and SaaS services;</li><li>Provide answers and recommendations to security-related questions, queries, and requests related to GoTo enterprise IT systems and SaaS services;</li><li>Develop, review, and improve technical documentation and reports relevant to the security controls used by GoTo corporate IT systems and SaaS services.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, networking, and general security concepts (a bachelor's degree or higher is a plus).</li><li>At least 5 years of experience in cyber security, preferably with hands-on experience in implementing and maintaining the security of enterprise grade IT systems and SaaS services, e.g., Google Workspace, Microsoft 365, Slack, SAP, or Atlassian;</li><li>Proven hands-on experience in the configuration and troubleshooting of enterprise security solutions, e.g., EDR, MDM, DLP, Firewall, and/or SASE;</li><li>Proven hands-on experience in the management and security of enterprise collaboration tools such as Google Workspace, Microsoft 365, or Lark;</li><li>Coding and scripting skills especially for automation is highly desired;</li><li>Ability to develop clear and concise documentation and reports.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Enterprise Information Security Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","descriptionBodyPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b","applyUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b/apply"},{"additionalPlain":"About The Team\n\nCost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Cost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.</div>","categories":{"commitment":"Permanent","department":"FinTech - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718852731439,"descriptionPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","id":"60283bc5-9f60-400a-8289-bcbe332fbc09","lists":[{"text":"What You Will Do","content":"<li><b>Planning</b>: Work closely with the budget owner to prepare annual budget planning, re-forecast, rolling forecast on a periodic business cycle. Review budget activities completed by the budget owner with accurate baseline, information, and proper justification</li><li><b>Controlling</b>: Responsible for reviewing and approving each spending related to Opex and Capex according to the applicable Expense Management PolicyWork closely with the budget owner to ensure each spending request is based on business requirements, supported by budget availability, and budget transfer process (if required). Collaborate with the other stakeholders in building the right cost base e.g., Procurement, Budget owner, etc.</li><li><b>Monitoring</b>: Create and refine report in order to provide the right data and information to the CFO, FBP and Budget Owner to analyze the actual spends against the available budget on monthly basis with a pre-defined report including its associated drivers. Understand the variance including the explanation and/or justification from the Budget Owner whenever the spend exceeded the approved budget. Continue to work closely with the Budget Owner in supporting the identification of risks &amp; opportunities for cost-efficiency purposes. Highlight key financial issues and deliver the proposed solutions to the stakeholders, provide insightful financial analysis on a regular and ad-hoc basis such as but not limited to topline daily/weekly tracker, business unit performance review, and other financial ratios analysisIn certain circumstances, this candidate will work with Cost Management Head to support the entire products under GoTo Financial product or Function group.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's Degree in Accounting / Finance/ Business, or equivalent educational background</li><li>Minimum 5 years of working experience in Finance Business Partner / Cost Control areas</li><li>Able to build a financial model, proficiency in Microsoft Excel and Gsheet/Gdocs</li><li>Strong business, data-driven acumen, and ability to work with big database</li><li>Able to manage multiple stakeholders across various levels of seniority</li><li>Strong project management skills to manage complex projects; able to prioritize multiple internal and external stakeholders; and able to drive consensus</li><li>Strong team player; possesses team synergy skills with a high level of enthusiasm in collaborating with cross-teams</li><li>Able to work independently and high attention to detail with swift execution</li><li>Proficiency with Finance / Accounting tools (e.g. SAP and ERP) is a plus</li><li>Fluent in English (written and spoken)</li>"}],"text":"Financial Controller Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","descriptionBodyPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09","applyUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09/apply"},{"additionalPlain":"About the team \n\nThe Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. \n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. </div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721025492852,"descriptionPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","id":"a9daeacc-5dda-4735-ad7b-db35eb7593a6","lists":[{"text":"What you will do","content":"<li>Support Compliance and Regulatory Affairs matters in GoTo Financial Services operations, which includes but is not limited to business/product reporting and approval process with the regulators, compliance advisory assistance to business unit, as well as technical regulatory assessment</li><li>Provide Compliance advisory assistance for Financial Services operations, in both consumer and merchant-facing operation</li><li>Create and maintain the latest update of Financial Services regulations databases and provide/disseminate assessments on such regulations to the internal units in GoTo Financial</li><li>Provide assistance and support to the Head of Compliance and Senior Manager of Financial Services Compliance in any external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders</li><li>Give continuous support on the creation, standardization, and implementation of Financial Services Compliance, policies, terms &amp; conditions, internal working procedures, and standard operational guidelines</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law and Accounting. Having a master’s degree would be an advantage.</li><li>Possessing certifications in Risk Management/ IT Audit will be an advantage.</li><li>At least 4 years of mixed experience in the area of payment policy/ regulatory compliance.</li><li>Intermediate level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks, proactively choose the best solutions, and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including builds credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"FinServ Compliance Officer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6","applyUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6/apply"},{"additionalPlain":"The Fleet Team is a newly established team in Gojek. The mission of the team is to create strategic partnerships to increase GoCar supply in a sustainable way, which in turn will enhance customer reliability, and create a bigger market for ride-hailing in Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Fleet Team is a newly established team in Gojek. The mission of the team is to create strategic partnerships to increase GoCar supply in a sustainable way, which in turn will enhance customer reliability, and create a bigger market for ride-hailing in Indonesia.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1722249916751,"descriptionPlain":"As Fleet Account Manager, you will be responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).\n","description":"<div><span style=\"font-size: 10pt\">As Fleet Account Manager, you will be&nbsp;responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).</span></div>","id":"c48698b4-3bff-4e56-b250-cadf67700c6d","lists":[{"text":"What you will do","content":"<li>Obtain in-depth and robust understanding of both Gocar &amp; fleet partners business needs / issues, at the same time act as a trusted advisor for them to sustain and grow their business</li><li>Create pipeline and bring in new fleet partners into Gocar ecosystem</li><li>Find ways to leverage Gojek’s existing structures (eg. driver engagement) to exert influence over driver’s SH/AR/CR/location</li><li>Develop end-to-end joint business plans, monitor fleet partner’s performance versus target, assess competitive benchmarking and anticipate potential business challenges</li><li>To take responsibility for all services that Gojek delivers to each account, become the single point of contact from Gojek for engagement, project delivery &amp; troubleshooting efforts</li><li>To playbook these efforts and scale your knowledge and best practices to operations team</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 6 years work experience in relevant sectors, e.g. account management, management consulting, PMO in reputable&nbsp; organizations</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in Bahasa Indonesia (must-have) and English (nice-to-have)</li><li>Strong business acumen (have a basic understanding of P&amp;L/profit &amp; loss)</li><li>Ability to deliver results and close win-win deals / agreements</li><li>Able to articulate knowledge and insights into document that can be leveraged across the orgarnization</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Fleet Account Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Fleet Account Manager, you will be&nbsp;responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).</span></div>","descriptionBodyPlain":"As Fleet Account Manager, you will be responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d","applyUrl":"https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d/apply"},{"additionalPlain":"About the Team\n\nWorking with our team is an exciting and enriching experience, as we play a pivotal role in shaping the frontend ecosystem of the organization. As a cohesive unit, we focus on several key aspects, making our collaboration both productive and rewarding.\n\nOur team takes pride in developing and maintaining the central design system. This system ensures consistency and efficiency across all our web applications, resulting in a seamless and unified user experience. We are at the forefront of building and optimizing our web platform tooling. These tools enhance our productivity and code quality, allowing us to deliver exceptional frontend solutions efficiently. We actively contribute to internal product development. Our expertise in frontend engineering enables us to align with product visions and business objectives, ensuring the successful delivery of high-quality products that delight our users. By adhering to industry standards and conducting thorough code reviews, we ensure that our codebases are consistent, maintainable, and secure. This commitment to excellence translates into reliable and robust applications.\n\nWorking together, we foster an inclusive and supportive environment where every team member's ideas and perspectives are valued. Our dedication to mentorship and knowledge sharing ensures that we grow both as individuals and as a team. As a member of our team, you will have the opportunity to expand your skills, learn from experienced peers, and make a meaningful impact on the organization's frontend landscape. Collaboration, innovation, and a passion for frontend development define us. We welcome individuals who share our enthusiasm and dedication to join us on this journey of building exceptional web experiences and driving standardization across our organization.\n\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Working with our team is an exciting and enriching experience, as we play a pivotal role in shaping the frontend ecosystem of the organization. As a cohesive unit, we focus on several key aspects, making our collaboration both productive and rewarding.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team takes pride in developing and maintaining the central design system. This system ensures consistency and efficiency across all our web applications, resulting in a seamless and unified user experience. We are at the forefront of building and optimizing our web platform tooling. These tools enhance our productivity and code quality, allowing us to deliver exceptional frontend solutions efficiently. We actively contribute to internal product development. Our expertise in frontend engineering enables us to align with product visions and business objectives, ensuring the successful delivery of high-quality products that delight our users. By adhering to industry standards and conducting thorough code reviews, we ensure that our codebases are consistent, maintainable, and secure. This commitment to excellence translates into reliable and robust applications.</span></div><div><br></div><div><span style=\"font-size: 16px\">Working together, we foster an inclusive and supportive environment where every team member's ideas and perspectives are valued. Our dedication to mentorship and knowledge sharing ensures that we grow both as individuals and as a team. As a member of our team, you will have the opportunity to expand your skills, learn from experienced peers, and make a meaningful impact on the organization's frontend landscape. Collaboration, innovation, and a passion for frontend development define us. We welcome individuals who share our enthusiasm and dedication to join us on this journey of building exceptional web experiences and driving standardization across our organization.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1722247155831,"descriptionPlain":"About the Role\n\nAs a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups. \n\nIf working on deep & challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">If working on deep &amp; challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!</span></div><div><br></div>","id":"f7107250-7aa4-487c-8821-8948dfb0fbc3","lists":[{"text":"What You Will Do","content":"<li>Work with engineers and business stakeholders to understand the nature and background of the problems</li><li>Pair with fellow engineers to dissect the incoming problem statement and contribute to the solutioning</li><li>Craft reusable, reliable, accessible &amp; delightful UI components that work flawlessly across various web browsers &amp; devices</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Build and maintain various utilities focused on improving designer or developer productivity</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Ensure that the application and its components are robust by writing automated tests which covers all the critical flows in the application.</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript</li><li>Solid command over React JS with the flavor of TypeScript</li><li>Keen design and UX sense to analyze and understand the designs and wireframes</li><li>Good understanding of common web security threats and practices along with OWASP 10</li><li>Experience with <a href=\"http://node.js\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Frontend Engineer - Web Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">If working on deep &amp; challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups. \n\nIf working on deep & challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3","applyUrl":"https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705377654170,"descriptionPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","id":"a3543985-6d2c-45cf-84f7-312ec7efed36","lists":[{"text":"What Will You Do","content":"<li>Write and deploy code that's clear, concise, performant, tested, and easy to understand by other teams and engineers</li><li>Participate in design reviews and own feature development from end to end</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices</li><li>Deep dive and debug production issues across services and levels of the stack when needed</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently</li>"},{"text":"What Will You Need","content":"<li>5+ years experience building consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Proficiency with one or more programming languages like Java, Go, and Kotlin.</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, asynchronous programming, fault tolerance and monitoring, performance, feature flags</li><li>Understanding how mobile/web applications interact with back-end and other systems. Experience in building frontend UIs is a bonus</li><li>Good understanding of SQL/NoSQL databases</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, GCP</li><li>Excellent verbal and written communication skills</li><div><br></div>"}],"text":"Full Stack Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","descriptionBodyPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36","applyUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36/apply"},{"additionalPlain":"About the Team :\nWe are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \nThis includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team :</b></div><div><span style=\"font-size: 10pt\">We are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><span style=\"font-size: 10pt\">This includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><span style=\"font-size: 10pt\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718186798651,"descriptionPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","id":"6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","lists":[{"text":"What You Will Do","content":"<li>Build highly reliable frontend apps through appealing visual design with API integrations to support continuing increases in adoption of the products within Gojek</li><li>Work with engineers to understand the nature and background of the problems.</li><li>Work closely with all Data Platform teams to develop and rollout high quality products</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Contribute to improving team relatedness, and helps build a culture of camaraderie</li><li>Continuously refactor applications to ensure high-quality</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript.</li><li>Solid command over React JS with the flavor of TypeScript.</li><li>Keen design and UX sense to analyze and understand the designs and wireframes.</li><li>Good understanding of common web security threats and practices along with OWASP 10.</li><li>Experience with <a href=\"http://node.js\" class=\"postings-link\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server.</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management.</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Fullstack Engineer - Engineering Platforms","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt;\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt;\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","descriptionBodyPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","applyUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</div><div>We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</div><div>Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718006842841,"descriptionPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","id":"7d1c915f-ac53-4a2c-887a-41bbbda48a26","lists":[{"text":"What You Will Do","content":"<li>Execute design tasks such as layout composition, image editing, typography, and color correction</li><li>Assist in the development of design concepts for various marketing collateral, including digital advertisements, print and digital materials, and more</li><li>Support the Art Director to provide visual assets for video and key visuals productions</li><li>Think creatively to generate visuals that connect with target audiences</li>"},{"text":"What You Will Need","content":"<li>A bachelor’s degree, with 3 years of experience in a related field</li><li>Proficiency in design software such as Adobe Creative Suite (Photoshop, Illustrator, and Premier), with a basic understanding of design principles and techniques</li><li>A portfolio showcasing examples of design work</li><li>Strong attention to detail and a passion for visual storytelling, with the ability to create compelling designs that resonate with the target audience</li><li>A can-do attitude with a determination to see tasks through to completion</li><li>Enthusiasm for design and a proactive attitude, with a desire to contribute ideas, and solve problems creatively</li>"}],"text":"Graphic Designer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","descriptionBodyPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26","applyUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26/apply"},{"additionalPlain":"About The Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Growth Analyst role will be reporting directly to the Head of Consumer Acquisition & Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Growth Analyst role will be reporting directly to the Head of Consumer Acquisition &amp; Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Consumer Experience","allLocations":["Jakarta"]},"createdAt":1721795385137,"descriptionPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","description":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","id":"5f86f9c4-80bc-437f-b09c-b61fd85c27eb","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Drive actionable insights recommendation such as making funnel conversion analysis, cohort analysis, long-term trends, user segmentation, etc.</li><li>Identify the business need and generate analysis&nbsp;</li><li>Create and manage dashboards and data pipelines to monitor metrics to measure business performance</li><li>Working closely with the Business team and other data team (Data Engineer, Business Intelligence) to implement data solution</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 2 years of working experience in data analytics field</li><li>Proficiency in data analysis tools, SQL. Strong analytical skills to interpret complex data sets and extract actionable insights.</li><li>High proficient in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficient in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Data Management: Familiarity with data collection, storage, and management best practices.&nbsp;</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li>"}],"text":"Growth Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb","applyUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb/apply"},{"additionalPlain":"About the Team\n\nThe Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720079397618,"descriptionPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","id":"9bc8bd8a-cadc-4942-81c4-193773a294df","lists":[{"text":"What You Will Do","content":"<li>Design and own growth strategy of GoPay Later product; make data-driven business decisions on a regular&nbsp;</li><li>growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps, and actual customer insights</li><li>Test and validate solutions through a proper experimentation process</li><li>Liaise with other analytical chapters within the Financial Services Platform as well as across Gojek such as Data Science, Data Engineering, Data Governance, Risk Analytics, etc, to ensure that initiatives are aligned and data integrity standards are adhered to.</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 2 years of working experience in an analytical role (data analyst / BI/data science/statistician, etc)</li><li>Strong SQL skills with expertise in either Excel/Python/R</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps</li><li>Strong project management skills to manage projects; able to work together with relevant units, also can manage and prioritize multiple internal stakeholders</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team</li>"}],"text":"Growth Analyst - GoPay Later","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","descriptionBodyPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df","applyUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713765081862,"descriptionPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","description":"<div><span style=\"font-size: 10.5pt\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","id":"761415aa-89b7-4ffb-a19b-2b91ac4243b4","lists":[{"text":"What You Will Do","content":"<li>Lead the strategy and growth function for GoModal. You will be collaborating with the Marketing &amp; Product teams on a daily basis.</li><li>Maintain rigor in analytical excellence in terms of data analytics, A/B test design, and appropriate statistical tests across the product funnel from acquisition, adoption, retention to monetization.</li><li>Discover growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps and actual customer insights.</li><li>Analyze our complex and ever-growing data, present insights, and propose strategic options to management to drive business decisions.</li><li>Test and validate solutions through proper experimentation process.</li><li>Importantly, using data to identify growth opportunities and problem solve so as to achieve business goals with metrics such as conversion rates of WL to submit KYC, adoption rate &amp; GTV (disbursement)</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 4 years of working experience in a growth or product role (growth marketing, data analyst, BI, strategy, etc).</li><li>Strong project management skill to manage complex projects; also can manage and prioritize multiple internal and external stakeholders.</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps.</li><li>Experienced planning, designing, and executing experiments. Also comfortable working with frequentist statistics to analyze experiment results.</li><li>Strong data visualization and data storytelling skills.</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team.</li><li>Preferred but not required: Strong SQL skills with expertise in either Excel/Python/R&nbsp;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Growth Lead (Merchant Lending)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","descriptionBodyPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4","applyUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714985249008,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","id":"2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Introduce beneficial business changes through well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve the business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resourcesProactively improve the operation process in the team and act on how to drive a faster, more effective, and efficient execution process through third-party tools or in-house service</li>"},{"text":"What You Will Need ","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience&nbsp;</li><li>Data analytics capability, have a good knowledge of SQL and experimentation processes; High Proficiency in Python and R is a plus</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Planning & Operation - GoFood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","applyUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e/apply"},{"additionalPlain":"About the Team \n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717479647909,"descriptionPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","id":"1fad1d82-dc7b-4d5a-b0d0-eb4678350242","lists":[{"text":"What You Will Do","content":"<li>Lead and Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Work closely with the Product, Marketing, Sales, Research, and Intelligence teams to understand merchant pain points and define the solution as well as Data, Ads, and Operation teams in the development and implementation of initiatives and strategies</li><li>Prepare reports of key merchant metrics analysis as a basis of rationale and recommendations to upper management, including CxOs of Gojek and GoTo Group</li><li>Conduct competitive benchmarking and analysis with local and international counterparts</li><li>Introduce beneficial business changes through a well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience</li><li>Strong critical thinking, coordination, and stakeholder management skills to drive analysis and cross-collaboration independently</li><li>Data analytics capability have a good knowledge of SQL and experimentation process; High Proficiency in Python and R is a plus</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also being a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Strategy Manager - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","descriptionBodyPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242","applyUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719458638459,"descriptionPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","description":"<div><span style=\"font-size: 10pt\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","id":"b68a9eb5-f615-441a-b04c-2d2c6a9d4703","lists":[{"text":"What You Will Do","content":"<li>Perform development and review of Business Continuity Management Framework and its supporting policies;</li><li>Strategize, coordinate, and provide challenge and advisory in the implementation of Business Continuity Programs such as BCP, BCP testing, Crisis Management exercise, and ways of integrating Business Continuity concept and awareness in the operational of business and support functions;</li><li>Respond to audit and regulatory requirements on BCM;</li><li>Design and deliver BCM communications and clinic sessions;</li><li>Provide Business Continuity update report to Management</li><li>Facilitate and support the execution of the plans at the time of a crisis event.</li>"},{"text":"What You Will Need","content":"<li>Minimum bachelor’s degree in relevant discipline from a reputable university</li><li>Minimum 8 years of Business Continuity Management experience in prominent consulting firms and/or multinational companies</li><li>Growth mindset, analytical, assertive and good interpersonal skill</li><li>Relevant BCM certifications&nbsp;</li><li>Good competency in English, verbal and written.</li>"}],"text":"Head of Business Continuity Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","descriptionBodyPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703","applyUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703/apply"},{"additionalPlain":"Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717651947726,"descriptionPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><span style=\"font-size: 16px\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"c838dc08-24e8-417c-9d70-a617bc58e200","lists":[{"text":"Responsibilities","content":"<li>Gojek is looking for an experienced technologist with a passion &amp; understanding of technology to lead its transportation product. Transport is one of the flagship products in GOJEK superapp. It is launched in Indonesia, Singapore and Vietnam.</li><div><br></div><li>As Head of Engineering of Transport, you will partner with GOJEK VP, Senior VP of technology, Transport Head of Business, Group Product Manager and other business stakeholders in the company to formulate a business strategy for Transport. You will work closely with PMs and Tech Leads in Transport to realize this strategy to make GOJEK a dominant player in markets.</li><div><br></div><li>Strategic thinking and strong business acumen along with deep technical expertise are essential in this role. We expect you to be well-versed in current technological trends and familiar with a variety of business concepts. If you are also an excellent communicator and public speaker, we’d like to meet you.</li><div><br></div><div>What you will do</div><div><br></div><li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Setup growth paths for the team and engage them in processes and practices that shall help scale engineering</li><li>Collaborate with cross functional teams and stakeholders (Business, Product, Data, UX, Platform, Devops etc.) to unlock the next phase of business growth.</li><li>Provide technology leadership to the team and foster engineering excellence.</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"Experience and Skills","content":"<li>Should have at least 9 years of hands-on experience in designing, developing, testing and deploying applications at scale.</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus.</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation.</li><li>Experience as people manager and passionate towards building and growing a high functioning team.&nbsp;</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions.</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities.</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Head of Engineering - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px;\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px;\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px;\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px;\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200","applyUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200/apply"},{"additionalPlain":"About The Team\nYou will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">You will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718871657577,"descriptionPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","id":"6dc20c4e-4d40-4f57-a138-4776013e454e","lists":[{"text":"What You Will Do","content":"<li>Oversee CS, Telesales, KYC, collection and FI team and Ops projects for our BNPL and cashloan product.&nbsp;</li><li>Develop &amp; Optimize Processes - Scale new and existing processes to allow the business to efficiently operate in Indonesia</li><li>Analytics - Analysis and tracking of onboarding, merchant experience and technical issues, risk management etc</li><li>Strategy - Choose which projects to prioritize, and set a timeline to reach goals quickly</li><li>Tool Improvements - Proactively search for new tools or ways which could improve a seamless support and setup experience, for both, merchant and buyer</li><li>Be fast, resourceful, and take initiative - Take ownership of regional commerce operations and do everything you can to support and enhance the quality of our services</li>"},{"text":"What This Role Needs","content":"<li>Min. 7 years experience in tech startup/fintech industry</li><li>Experience in operations strategy, sales strategy and product management is a big plus</li><li>Proven success in dynamic and complex environments, with a proven ability to rally teams and influence at all levels</li><li>Deep analytical skills, with high capacity to think strategically about complex issues, evaluate alternatives, and make compelling recommendations based on proven business case analysis</li><li>Outstanding communication skills, both verbal and written</li><li>Ability to lead complex and strategic initiatives and communicate effectively with technical teams</li><li>Ability to collaborate with various departments by utilizing superior relationship-building skills, interpersonal skills, and influence</li>"}],"text":"Head of Operation - Consumer Lending - #10162","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","descriptionBodyPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e","applyUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705905810213,"descriptionPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","description":"<div><b><span style=\"font-size: 18px\">About The Role</span></b></div><div><span style=\"font-size: 16px\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","id":"70493d8a-7d7f-4660-b1ed-c792d0d765be","lists":[{"text":"What You Will Do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What This Role Needs","content":"<li>At least 15 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Experienced in managing a huge team size</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closingExcellent in contract and commercial negotiation process</li><li>Experience in payment industry is a plus</li>"}],"text":"Head of Sales - Midtrans - #9618","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 18px;\">About The Role</span></b></div><div><span style=\"font-size: 16px;\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px;\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","descriptionBodyPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be","applyUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be/apply"},{"additionalPlain":"About The Team\nAs Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.\n\nOne of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing & executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.\n\nWe are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 14px\">As Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.</span></div><div><br></div><div><span style=\"font-size: 14px\">One of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing &amp; executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.</span></div><div><br></div><div><span style=\"font-size: 14px\">We are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Strategy","allLocations":["Jakarta"]},"createdAt":1708937527995,"descriptionPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","id":"7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","lists":[{"text":"What You Will Do","content":"<li>Design the overall end-to-end sales strategy which includes go-to-market (GTM) strategy and implied sales motions / incentives system</li><li>Define OKR &amp; building blocks for the entirety of nationwide sales team (Enterprise &amp; Small Medium Business teams) to ensure that company objectives are met - working closely with the product teams (including but not limited to GoFood, GoMart, GoCorp and GoPay)</li><li>Set sales targets in areas like product mix, sales volume, and market shares</li><li>Track OKR &amp; performance of the overall greater sales team (Enterprise, SMB Managed &amp; SMB Unmanaged teams) across all products</li><li>Oversee the execution of sales motions / building blocks: periodic review with working and/or leadership team, provide guidance to the overall sales strategy &amp; other relevant stakeholders</li><li>Establish a regular &amp; methodical planning rhythm to ensure that both sales team structure &amp; compensation plan are aligned to support reaching company targets. This would include merchant segmentation, sales structure review, sales earning optimization exercises, account mapping, territory planning; working together with the Head of Enterprise Sales and Head of SMB Sales</li><li>Become the bridge between Sales HQ &amp; on-the-ground merchant-facing teams to ensure seamless &amp; effective execution</li>"},{"text":"What This Role Needs","content":"<li>At least 10 years of relevant work experience in strategy, preferably within mid-to-senior management level from multinational company</li><li>Have strong analytical thinking and problem solving skills using various tools and methods</li><li>Comfortable working under pressure in a fast-paced and ambiguous environment</li><li>Ability to prioritize &amp; multitask across different initiatives (balancing breadth vs in-depth)</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Have great presentation skills - esp. the ability to present to senior management &amp; leadership</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>Fluent in Bahasa Indonesia &amp; English</li>"}],"text":"Head of Sales Strategy - #10056","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","descriptionBodyPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","applyUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721030934590,"descriptionPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","description":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","id":"9c0a73a5-09ce-4b06-8527-9415ef3d393c","lists":[{"text":"What You Will Do","content":"<li>Lead a team of IT Auditors in planning, preparation, coordination, and execution of audits to evaluate the adequacy and effectiveness of technology infrastructure, application, and process controls.</li><li>Provide clear, concise, and organized documentation of the audit processes and findings.</li><li>Identify and evaluate complex technology and business risks, implications, and related opportunities for improvements of internal controls.</li><li>Manage audit projects effectively – resource allocation, deliver on commitment, time management and quality reviews.</li><li>Serve as the Audit Committee Secretariat responsible for coordination of materials across the governance teams for periodic AC meetings.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Must have a minimum of 8-10 years of experience in technology audits, with at least 5 years in public accounting / advisory firms.&nbsp;&nbsp;</li><li>Must have strong practical experience in testing of GITC, application controls, ISO 27K, cybersecurity risk assessment, and ERP’s.&nbsp;</li><li>Must possess CISA certification at a minimum - additional certification in cyber, risk and technology governance preferred.&nbsp;</li><li>Knowledge and experience with OJK and Bank Indonesia (BI) technology audit requirements preferred.&nbsp;&nbsp;</li><li>Experienced with coaching and developing junior team members, strong confidence to interact with various stakeholders, excellent project management and organizational capabilities, ability to complete tasks and audit projects within tight deadlines.</li><li>Strong communication in English (verbally and in writing) and PowerPoint preparation skills.&nbsp;</li><li>Highly self-motivated, inquisitive (with a keen interest in learning new processes and technologies) and strive to continuously develop technically and professionally.</li>"}],"text":"Internal Audit Senior Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","descriptionBodyPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","hostedUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c","applyUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c/apply"},{"additionalPlain":"Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Corporate Affairs","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1720685009263,"descriptionPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","description":"<div><span style=\"font-size: 11pt\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","id":"fc5f2c90-038e-4c53-9971-2ae72f680c03","lists":[{"text":"What you will do","content":"<li>Gojek Singapore communications:</li><div>Serve as the overall PR point of contact and develop communications strategies for the Singapore market, collaborating with the Gojek Singapore leadership team.</div><div>Develop and execute PR plans for Singapore-related announcements, handling all external-facing communications and materials.</div><div>Engage with Singapore media, manage media queries, and manage crisis and issues across media <a href=\"http://channels.Proactively\" class=\"postings-link\">ch</a>annels</div><div>Proactively seek thought leadership opportunities and lead OKR reporting for PR-related <a href=\"http://metrics.GoTo\" class=\"postings-link\">me</a>trics</div><div><br></div><li>GoTo Group communications support:</li><div>Support Group-level announcements and the development of associated English language communication materials</div><div>Maintain relationships with key international media contacts and handle media queries</div><div>Support issues management teams.</div><div>Develop thought leadership content, manage media opportunities and awards, and oversee a number of owned channels.</div><div><br></div>"},{"text":"What you will need","content":"<li>Excellent writing skills - proficiency with Chinese language media in Singapore is a bonus</li><li>Proven ability to build and maintain relationships with media contacts</li><li>Experience in pitching stories and managing media inquiries.</li><li>A cool head in a crisis</li><li>Meticulous approach to reviewing materials and ensuring accuracy</li><li>Ability to manage multiple projects without compromising quality.</li><li>Flexibility to manage unexpected challenges and opportunities</li><li>Enthusiasm for travel (regular travel to indonesia will be required) </li><div><br></div>"}],"text":"International & Singapore Communications Manager","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 11pt;\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt;\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","descriptionBodyPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03","applyUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03/apply"},{"additionalPlain":"About the Team\n\nThe IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721378203517,"descriptionPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","id":"4cb00240-117e-4ace-a959-fc567e447d5f","lists":[{"text":"What You Will Do","content":"<li>Manage multiple complex IT Finance initiatives</li><li>Ensure initiative deliveries are on time and adhere to IT Project Life-Cycle standards</li><li>Ensure information is delivered to the business through the correct channels, ensuring compliance with all controls and security requirements</li><li>Manage multiple internal stakeholders across countries and business units</li><li>Provide regular status updates to GoTo leaders and stakeholders</li>"},{"text":"What You Will Need","content":"<li>8+ years of work experience in IT project/program management in Finance Domain</li><li>Strong track record of leading successful IT projects/programs from start to finish&nbsp;</li><li>Ability to multi-task and effectively manage several projects in parallel</li><li>Ability to influence large, cross-functional teams</li><li>Strong interpersonal, facilitation, and leadership skills</li><li>Experience in managing Corporate Finance, Enterprise Data, and Enterprise business processes is highly desirable</li><li>Drive adherence to SDLC processes, drive to implement new processes and procedures applying industry knowledge and experience to cut costs, gain efficiencies, minimize risks, and reduce time to deploy, with attention towards automation and continuous improvement; make recommendations for process improvements; track and document all process improvements;&nbsp;</li><li>Good communication skills in English both oral and written</li>"}],"text":"IT Finance Project Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","descriptionBodyPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f","applyUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f/apply"},{"additionalPlain":"About the Team\n\nJoining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Joining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713930486899,"descriptionPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","id":"36caef5f-7a1c-4326-80b4-8c146060ac70","lists":[{"text":"What You Will Do","content":"<li>Develop and maintaining IT policies, standards and procedures according to applicable internal and external requirements, including the applicable regulations in Indonesia an other countries where GTF operate;</li><li>Develop and maintain compliance, governance and risk-related IT and business process flow;</li><li>Coordinating with compliance team to ensure that every initiative, development and collaboration are comply with the standards and regulations (internal and external);</li><li>Conduct routine evaluation of policies and procedures implementation and ensure best practice risk mitigation and assessment functions are maintained to comply with the company's strategy;</li><li>Coordinate with related IT work units to follow up on data requests and internal audit findings, external audits and regulators;</li><li>Develop the process and conduct the activities to safekeep or archive of every IT development document in a regular basis;</li><li>Implementing a good governance organization using the ISO27001, ISO 27701, PCI DSS framework and other relevant Technology &amp; Security best practices;</li><li>Develop and implement the RBAC and least privilege of access management in the GTF technology stack</li><li>Act as a Subject Matter Expert to the stakeholders and provide relevant &amp; applicable consultation for addressing the IT GRC requirement in lending product &amp; services.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years experiences as Information Security, IT Governance, Risk and Compliance (IT GRC) or IT Auditors;</li><li>Demonstrate excellent communication and writing skills and proficient with English written and spoken</li><li>Experienced in developing and maintaining IT and/or information security policies and procedures;</li><li>Excellent knowledge in developing risk management and IT framework, BIA, BCP and BCM Framework</li><li>Experienced in report document development and delivery;</li><li>Experienced in dealing with regulatory audit to represent the organization IT GRC operations;</li><li>Having good knowledge with local and regional payment &amp;&nbsp; lending regulatory requirements and how they impact IT policies (having experience is preferred);</li><li>Having excellent experience with ISO 27001, ITIL. COBIT, and PCI-DSS standards;</li><li>One or more of the following or equivalent certifications preferred: CISA, CRISC, ITIL, COBIT is preferred</li>"}],"text":"IT GRC Senior Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","descriptionBodyPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70","applyUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70/apply"},{"additionalPlain":"About The Team\n\nGoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.\n\nOur achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.\n\nAs a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design & Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.</div><div><br></div><div>Our achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.</div><div><br></div><div>As a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design &amp; Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720592684329,"descriptionPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","description":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","id":"da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of your Writer lead, and follow the predefined process that has been set by the team</li><li>Understand the product briefs and present ideas/solutions to the team under the supervision of your writer lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Proactively attend design reviews to gather feedback and provide critiques if needed</li><li>Proactively seek knowledge about UX</li><li>Participate in the end-to-end design process with peer researchers, designers, business, product and engineering teams. You will also get to engage with marketing and customer care unit to ensure the content is cohesive</li><li>Own your assigned streams and organize assigned tasks; which includes communicating updates and progress via the provided forums and channels. Be flexible to collaborate with other streams when needed</li>"},{"text":"What You Will Need","content":"<li>At least 1 year of experience in product writing for digital products or services</li><li>Strong understanding of writing fundamentals, critical/creative/structured thinking skills, grammar in both English &amp; Indonesian, and a familiarity of product design/ design thinking frameworks in order to further develop your writing output</li><li>Excellent communication and grammar skills in both English and Indonesian, both verbal and written, to effectively collaborate with stakeholders of varying seniority and backgrounds</li><li>A user-centric mindset in order to see things from their perspective, understand their concerns and feedback, and incorporate these insights into the work you produce</li><li>A drive to always find the root cause of an issue and validate your design - either through quantitative or qualitative research</li><li>A structured portfolio of written work that shows your ability and problem solving skills, a bonus if it demonstrates business impact and results</li><li>Ability to handle multiple tasks and prioritize work simultaneously</li><li>Demonstrate a detailed-oriented thought process with excellent documentation discipline</li>"}],"text":"Junior UX Writer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","descriptionBodyPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","applyUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d/apply"},{"additionalPlain":"About the Team\n\nTransport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.\n\nDespite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Transport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.</div><div><br></div><div>Despite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. </div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899257808,"descriptionPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","id":"f1d481f6-4e2d-401b-b310-fca641ab29d4","lists":[{"text":"What you'll do","content":"<li>Lead, mentor and recruit a team of highly talented and motivated engineers</li><li>Build and deploy features iteratively in production</li><li>Work cross-functionally with product, engineering and design teams across Gojek</li><li>Collaborate with internal teams to build and iterate on features</li><li>Build delightful user-facing experiences with smooth performance</li><li>Mentor and provide feedback to colleagues, participate in organisation building</li><li>Participate in research trips to better understand aspirations and pain points of our customers</li>"},{"text":"What you'll need","content":"<li>Should atleast have 6 years of relevant experience</li><li>Deep understanding of the iOS frameworks like UIKit, Foundation, etc.</li><li>Experience developing iOS apps in Swift</li><li>Attention to detail, particularly around software engineering fundamentals, testing methodologies, and quality</li><li>A strong customer focus</li>"}],"text":"Lead - iOS (Transport)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4","applyUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720610213311,"descriptionPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","description":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","id":"c9452ba2-cbb3-4ea5-83f7-79e765a67e58","lists":[{"text":"What You Will Do","content":"<li>As the Lead Auditor, you will support the design of risk-based audit plan influenced by regulatory compliance requirements, business needs and inputs from the governance teams (ERM, Ethics and Regulatory Compliance). You will deliver the audit as planned, discussion of issues with business and Group Audit, write up of report, advise and monitor on remediation progress. </li><div><br></div><div>Expectations of the role include: </div><div><br></div><li>Ability to deliver audit engagements independently and efficiently</li><li>Effective verbal and written communication (in Bahasa and English) of audit findings, remediation and reports to management.</li><li>Active participation and contribution to team discussion, audit planning, and stakeholder engagements.· &nbsp; </li><li>Ability to analyze operational process, regulatory issues and root cause.</li><li>Strong focus on quality deliverables such as audit report, work paper write ups, and presentation.</li>"},{"text":"What You Will Need","content":"<li>Mandatory: Minimum 8 years of audit experience obtained from public accounting and financial services internal audit roles.</li><li>Mandatory:&nbsp; Understanding and experience complying / auditing of relevant OJK regulations for multi-finance institutions.</li><li>Relevant certification in audit and risk preferred.</li><li>Highly motivated, demonstrated leadership attributes, meticulous attention to detail and problem solving</li><li>Effective communication in both Bahasa and English (verbal and written).</li><li>Ability to use data analysis tools (like ACL, MS Excel, Tableau, etc.).</li>"}],"text":"Lead Internal Auditor","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","descriptionBodyPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58","applyUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58/apply"},{"additionalPlain":"About The Team\nOur data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n","additional":"<div><b>About The Team</b></div><div>Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1719896801671,"descriptionPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","id":"4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","lists":[{"text":"What You Will Do","content":"<li>Manage data science infrastructure to streamline model development and deployment</li><li>Define and build scalable data pipelines that enables data scientists to build better models</li><li>Implement cutting edge big data frameworks to support batch and real-time jobs</li><li>Identify possible bottlenecks in the system and perform optimization</li><li>Build dashboards, models and deliver insights to support business analytics</li><li>Monitor and provide support to our infrastructure and production models</li><li>Mentoring team members through code review and knowledge sharing</li>"},{"text":"What You Will Need","content":"<li>At least 7 years of hands-on experience at large scales in data science / software engineering</li><li>Ability to write clean and structured SQL, Python and Shell programs</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Kubenetes, Docker, Infrastructure as Code, RDBMS and NoSQL Databases</li><li>Good understanding of machine learning techniques and algorithms</li><li>Good experience in serving real-time, production-level machine learning models</li><li>Management experience is preferred</li><li>Excellent communication skills</li>"}],"text":"Lead MLOps Engineer","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","descriptionBodyPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","applyUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0/apply"},{"additionalPlain":"About the Team\n\nThe GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.</div>","categories":{"commitment":"Permanent","department":"ODS - Transport & Mobility","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718255937171,"descriptionPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","id":"8bf17375-6318-400f-8216-4a132071777a","lists":[{"text":"What You Will Do","content":"<li>Roadmapping → Establish strategic objectives, roadmap and timelines to guide the development and enhancement of the GoCorp platform</li><li>Focus on optimizing the client experience, ensuring the platform meets and exceeds user needs and expectations. Execute with precision make sure products and features are launched in timely manner</li><li>Seek product ideas and feedback based on both quantitative and qualitative date, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that one size doesn’t fit all and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Work closely with business, sales, and marketing teams to align product strategies and objectives. Ensuring the all teams runs with the same drumbeat&nbsp;</li><li>Ensure seamless coordination with other product teams connected to the GoCorp platform to maintain a cohesive product ecosystem</li>"},{"text":"What You Will Need","content":"<li>Proven experience if min 5-6 years in product management, preferably within a tech or platform-based company and B2B product</li><li>Strong strategic thinking and planning skills with the ability to set and achieve the mid term and long-term objectives</li><li>Data oriented – demonstrated an ability to balance between quantitative and qualitative data to optimize client experience.</li><li>Exceptional problem-solving skills with a proactive approach to overcoming challenges</li><li>Excellent collaboration skills with experience working across multiple departments</li><li>Proficiency in managing the entire product lifecycle, from concept to launch and beyond</li><li>Strong communication skills to articulate product vision and objectives effectively to diverse stakeholders</li><li>Solid understanding of the technical aspects of platform development and integration.</li><li>Fluent in written and verbal english</li>"}],"text":"Lead Product Manager, GoCorp","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a","applyUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1716776042348,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"4a126665-42d6-4a36-82a5-089dca789f41","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Nurturing &amp; mentoring 5-7 engineers members</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize their ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 7-8+ years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Leadership experience in leading a distributed team of software engineers</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>Working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, xgboost, Keras</li><li>Prior experience with cloud provider (GCP is a plus)</li>"}],"text":"Lead Software Engineer - Data Science Platform","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41","applyUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719911495540,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","id":"a593bf17-baf2-479e-8154-c69d6a7d4f09","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost-effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems </li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure </li><li>Enhance code quality and product performance through continuous improvement and innovation </li><li>Collaborate and communicate effectively with teams across multiple geographies </li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves </li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices </li>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Erlang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with messaging protocol such MQTT &amp; prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Engineering Platforms","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09","applyUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. \n\nAt the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. </div><div><br></div><div>At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</div><div><br></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1711535878605,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","id":"3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems</li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure</li><li>Enhance code quality and product performance through continuous improvement and innovation</li><li>Collaborate and communicate effectively with teams across multiple geographies</li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves</li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in working with end to end Observability stack. Hands on experience in building and managing the telemetry pipeline at large scale</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with Grafana stack, Cortex, SLI/SLO platforms is a plus</li><li>Prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Observability","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","applyUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a/apply"},{"additionalPlain":"About the Team :\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</div><div><br></div><div>We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899083492,"descriptionPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","id":"9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences with minimal guidance for one of the world's fastest growing companies in travel</li><li>Understand, design and build to optimize in terms of resources used on the devices as well as simplify to meet the challenges of our always on-the-go users</li><li>Translate business requirements into scalable and extensible design</li><li>Partner with the product management team to define and execute the feature roadmap.Be responsible for defining and executing for complex, long term initiatives and help the team objectively lay out the roadmap and execute against smaller milestones</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Coordinate with cross functional teams (Backend, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence. Be the flag bearer for setting long term execution strategies and bring about the culture of operational excellence in the team</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in Android application development and product delivery</li><li>Predictability and balance of product delivery speed and quality</li><li>In depth knowledge of Android Apps architecture and implementation including proficiency in Kotlin, Architectural Components, Git, and Gradle</li><li>Understanding of TDD, Dependency Injection principles, Mobile Performance Tuning (Load time, Crash/ANR/Memory Leak tracking, Network optimisations)</li><li>Strong problem solving and analytical skills and a proven track record of being able to respond effectively to customer situations</li><li>A command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>A track record and passion for improving the code structure and architecture to improve testability and maintainability</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><div><br></div>"}],"text":"Lead Software Engineer - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","applyUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1704273923584,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","id":"2d3aae20-ff7e-4afb-8164-a351661c1680","lists":[{"text":"What You Will Do ","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest-growing company in the transportation industry&nbsp;</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Partner with the product management team to define and execute the feature roadmapCoordinate with cross-functional teams (Mobile, DevOps, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building the next generation of Gojek services</li>"},{"text":"What You Will Need ","content":"<li>Should have at least 6 years of hands-on experience in designing, developing, testing and deploying applications on Java or Go for large scale applications</li><li>Proficient in System Design, OOP, SQL, Linux/Unix, and Design Patterns. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities, through self-discovery or by vouching for exploratory tasks</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Lead Software Engineer (IC) - Go-Food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680","applyUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680/apply"},{"additionalPlain":"About The Team\n\nWe are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success\n\nWe're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>We are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success</div><div><br></div><div>We're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.</div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1721801286779,"descriptionPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","id":"ad8bd932-3494-4181-bd93-282665dce81d","lists":[{"text":"What You Will Do","content":"<li>Training Product Development: Develop and maintain detailed training materials, including manuals, user guides, and online resources, tailored to various audience levels. Collaborate with product managers, engineers, and other stakeholders to stay updated on product features and enhancements</li><li>Facilitation and Delivery: Conduct training sessions, both in-person and virtually, mainly for internal teams. Utilize a variety of instructional techniques and formats, such as role-playing, simulations, and interactive workshops</li><li>Assessment and Evaluation: Create and implement assessment tools to measure training effectiveness and knowledge retention. Gather feedback from trainees and use it to improve future training sessions</li><li>Support and Collaboration: Provide ongoing support and consultation to trainees post-training. Work closely with sales teams and internal stakeholders to address any training-related issues and ensure customer satisfaction to achieve business goals</li><li>Continuous Improvement: Stay current with the latest product developments and industry trends. Incorporate new training methodologies and technologies to enhance the learning experience.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or higher; majoring in Business, Economics, or relevant fields</li><li> 2 or 3 years of experience in a product training or related role within the tech industry. Has proven experience in developing and delivering training programs</li><li>Excellent presentation and communication skills</li><li>High attention to detail, has ability to explain complex technical concepts in a clear and accessible manner</li><li>Strong organizational and project management skills</li><li>Ability to adapt training methods to different learning styles and audiences</li><li>Ability to drive changes successfully and to keep people motivated in a highly changing environment&nbsp;</li><li>Proactive, ability to work in a team, and a strong can do attitude.</li>"}],"text":"Learning & Development Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d","applyUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713944910535,"descriptionPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","id":"cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Proactively establish and strengthen relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia.</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals.</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors.</li><li>Project Leadership: Lead multiple projects in partnership with government institutions, focusing on Tech and the Digital Economy.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances.</li><li>Project Management: Oversee public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred.</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government.</li><li>Established network among government stakeholders with a proven impact on policy decisions.</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Manager of Food & Groceries Regulatory","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","applyUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719989851823,"descriptionPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","description":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","id":"ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","lists":[{"text":"What You Will Do","content":"<li>Maintain MI’s automation backend availability on Google Cloud Project&nbsp;</li><li>Continuously developing data pipeline architecture to ensure excellent performance&nbsp;</li><li>Do complex data analysis which are related to the Market Intelligence topics</li><li>Continuous knowledge update on latest tech capability to enhance the Market Intelligence deliverable in terms of depth, speed and variety of sources of references</li><li>Build and maintain a playbook for Market Intelligence data engineering projects</li>"},{"text":"What You Will Need","content":"<li>At least 2 years in <b>Data Engineer </b>roles</li><li>Talks in Python &amp; Linux</li><li>Exposure to data modelling would be preferred</li><li>Loves to experiment on the latest tech trends</li><li>Passionate in problem-solving and Root Cause Analysis (RCA)</li>"}],"text":"Market Intelligence (Data Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","applyUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4/apply"},{"additionalPlain":"Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.\n\nAs a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. \n","additional":"<div><span style=\"font-size: 9pt\">Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.</span></div><div><br></div><div><span style=\"font-size: 9pt\">As a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. </span></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720579532578,"descriptionPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","description":"<div><span style=\"font-size: 9pt\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","id":"967cfe0a-0243-4a2d-8813-038c355e43c3","lists":[{"text":"What you will do","content":"<li>Manage the marketing budget and ensure efficient allocation as well as prepare the report and regularly present it to senior management</li><li>Lead marketing metrics development, monitoring, and performance analysis periodically, as well as identify areas for <a href=\"http://improvement.Stay\">improvement.</a></li><li><a href=\"http://improvement.Stay\">Stay</a> updated on industry trends and the competitive landscape to inform strategic decision</li><li>Lead marketing campaigns development, monitoring, and evaluation incl. creative &amp; media strategy development &amp; execution with relevant stakeholders</li><li>Actively collaborate across functions &amp; streams especially product and strategy &amp; planning team in growing Transport business.</li><div><br></div>"},{"text":"What you will need","content":"<li>Bachelor's degree from a reputable university or equivalent practical experience</li><li>Min 4 years of experience working in a brand or product marketing field in FMCG, technology, telecommunication, or start-up</li><li>Excellent written &amp; verbal communication abilities at the business level with strong presentation skills to represent the Marketing team in functional meetings</li><li>Ability to work in a fast-paced, deadline-driven, and VUCA (volatile, uncertain, complex, and ambiguous) work environment</li><li>Strong capacity planning and reporting abilities; strong commercial sense and logical thinking skills to think outside the box as well as an understanding of budgeting, financial planning, and marketing <a href=\"http://metrics.Strong\">metrics.</a></li><li><a href=\"http://metrics.Strong\">Strong</a> analytical and quantitative skills; ability to use hard data and metrics to back up assumptions, and recommendations, and drive actions.&nbsp;</li><li>Familiarity with data analysis tools and software (SQL, Tableau, and Google Analytics)</li><div><br></div>"}],"text":"Marketing Planning Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","descriptionBodyPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3","applyUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3/apply"},{"additionalPlain":"About The Team\n\nOur Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media. \n\nAs a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media.&nbsp;</div><div><br></div><div>As a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!</div>","categories":{"commitment":"Internship","department":"HoldCo - Corporate Affairs","location":"Jakarta","team":"Media Intelligence","allLocations":["Jakarta"]},"createdAt":1719818000669,"descriptionPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","description":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","id":"a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","lists":[{"text":"What Will You Do","content":"<li>Monitor corporate news and other related information across channels (print, online, and social media).</li><li>Gather and analyze data from media monitoring to gain insights into public perception of the company and its performance.</li><li>Extract data and present interesting information from findings.</li><li>Identify trends and issues relevant to the company’s needs.</li><li>Collaborate to provide data-driven insights for other teams</li>"},{"text":"What Will You Need","content":"<li>Undergraduate students, preferably from Economics, Business, Computer Science, Marketing, Public Relations or Literature.</li><li>High proficiency in English and Bahasa Indonesia, both written and verbal.</li><li>A critical thinker, observant, and detail-oriented with vast knowledge of current issues and trends.</li><li>High willingness to learn.</li><li>Comfortable handling large data sets.</li><li>Knowledge in Ms Excel.</li><li>A collaborative team member as well as an independent self-starter.</li>"}],"text":"Media Intelligence Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","descriptionBodyPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","applyUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb/apply"},{"additionalPlain":"About The Team\n\nThe management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.\n\nThe AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.</div><div><br></div><div>The AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.</div>","categories":{"commitment":"Permanent","department":"FinTech - AML/CFT","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719311112001,"descriptionPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","description":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","id":"f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","lists":[{"text":"What You Will Do","content":"<li>As an official directly appointed by the relevant Director and responsible for the implementation of AML CFT in the company.</li><li>A pointed person for any Regulatory Compliance matters/projects as well as internal or external auditors in compliance reviews.</li><li>As an industry expert, keep track of the latest developments around regulations and find smart solutions to mitigate ML/TF risks</li><li>Remain knowledgeable of new or changing regulations, regulatory expectations, market conditions, and industry best practices and find smart solutions to mitigate ML/TF risks</li><li>Ensure Subject Matter Experts participate in all activities where expertise is required, including but not limited to, risk assessments, policy writing, training development, advice to the business, monitoring activities, and reporting</li><li>Provide senior management with actionable advice on how to effectively manage AML/CFT-related risks</li><li>Ensure all regulatory reporting requirements related to AML/CFT themes are met</li><li>Ensure implementation AML CFT regular trainings as well to Business Unit and Support Function and to liaise with the Learning &amp; Development PAC;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years in this role in the AML/CFT</li><li>You have extensive knowledge of the payments and or the banking/finance industry</li><li>A thorough understanding of AML/CFT laws and regulations incl. risks, controls, industry best practices and regulatory requirements</li><li>An excellent and direct communicator who talks straight without being rude</li><li>You have the ability to clearly explain AML CFT compliance and related risks, develop sound mitigation strategies, and find workable solutions&nbsp;</li><li>You have extensive experience representing and leading meetings with regulatory agencies, examiners and auditors</li><li>You have the ability to structure and prioritize in a high-volume, fast-paced environment and drive a process to completion</li><li>You are a team player that does not shy away from taking ownership</li>"}],"text":"Merchants AML/CFT Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","descriptionBodyPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","applyUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713245102772,"descriptionPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","description":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","id":"3f4f687f-8599-4d5c-96d5-8af234c3b09d","lists":[{"text":"What You Will Do","content":"<li>Identify and define business opportunities that aligns with the overall merchant services business objectives</li><li>Translate business opportunities into a fit problem statement and able to measure the priority of the problem&nbsp;</li><li>Collaborate with Product Team to develop a merchant focused product in onboarding and support&nbsp;</li><li>Develop Go-To Market plan and oversee the product adoption from funnel conversion rates and merchant experiences during the process.&nbsp;</li><li>Monitoring the product life cycle and continuously improved the product with a data driven decision making process</li><li>Engaged sales and ops team to deliver the best onboarding and support experience for merchants</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of working experience, experience in product and project management is a plus.&nbsp;</li><li>Possess a strong sense of agency in navigating and creating clarity in ambiguous situations.</li><li>Ability to break down complex problems, identify use cases and solutions, and thrive in unstructured environments.</li><li>Comprehensive understanding of data, design, research, and business processes, with the ability to effectively collaborate with diverse teams.</li><li>Strong analytical and quantitative skills, with the capability to utilize data and metrics to support requirements and features.</li><li>Effective communication skills to articulate strategy, insights, priorities, and plans coherently to all levels of management.</li><li>Meticulous attention to detail, with a commitment to upholding high standards and managing multiple, competing priorities concurrently with minimal supervision.</li>"}],"text":"Onboarding & Support Business Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","descriptionBodyPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d","applyUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"Lending Operations","allLocations":["Jakarta"]},"createdAt":1720692666755,"description":"","descriptionPlain":"","id":"0ae5053b-3c5f-432a-9b69-b4cdefb01b79","lists":[{"text":"What You Will Do","content":"<li>Master all Consumer Lending Operations-related data points, including Customer Service, KYC, Telesales, and Transactional Data.</li><li>Manage all Operations Dashboards and Reporting to ensure timely and accurate availability.</li><li>Provide analytical insights leading to actionable plans with positive impacts for stakeholders.</li><li>Support the Head of Operation and other stakeholders in executing operational experimentation and enhancing workflow automation processes.</li><li>Lead, mentor and develop Operation BI team member.</li><li>Assist Operation stakeholders in dealing with Fraud investigation, Campaign Setup, and regulatory reporting and audit preparation</li><li>Analyze, evaluate, and initiate improvements in day-to-day operations for efficiency, effectiveness, and scalability.</li><li>Develop job automation to build Datamart-level tables in Big Query for Operational Dashboard Reporting.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's Degree in Engineering, Mathematics, Statistics, or a related discipline is required.</li><li>5 years of experience in a fast-paced environment, with a background in project management and data analytics.</li><li>Possesses strong analytical, planning, and problem-solving skills.</li><li>Proficient in SQL and Advanced Excel, with a high level of competence in working with numerical data sets. Knowledge of Python and experience in automating tasks is highly advantageous.</li><li>Familiarity with at least one business intelligence tool such as Google Data Studio (Looker), Power BI, or Tableau is preferred.</li><li>Ability to work independently with excellent time management skills, collaborating effectively with cross-functional teams to drive initiatives aligned with organizational objectives and Key Results (OKRs).</li><li>Exceptional communication and interpersonal skills, capable of articulating complex ideas to non-technical stakeholders with clarity and precision.</li><li>Familiarity with data warehousing concepts and methodologies is considered a plus.</li>"},{"text":"About The Team","content":"<li>Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</li><li>Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly. In the coming year, in light of our new GoTo collaboration, we have exciting plans to scale up our team in effort to field the massive growth of our data pool.&nbsp;</li>"}],"text":"Operation Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79","applyUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79/apply"},{"additionalPlain":"Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy & Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs\n","additional":"<div><span style=\"font-size: 10pt\">Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs</span></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720522525041,"descriptionPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","description":"<div><span style=\"font-size: 10pt\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","id":"719f7a78-460a-4496-9298-ca57b835b120","lists":[{"text":"What you will do","content":"<li>Manage operational relationships with Fleet partners</li><li>Gain understanding of the mechanics of Fleet management, and identify pain points</li><li>Provide first level support for Fleet partners to ensure their business can thrive sustainably</li><li>Enhance the dynamic relationships among Gojek, Driver Partners, and Fleet Partners</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 3 years work experience in relevant sectors, e.g. Operations, Process Improvement and Management</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in English and in Bahasa Indonesia</li><li>Strong sense of business and tech processes</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Operation Support Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","descriptionBodyPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120","applyUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120/apply"},{"additionalPlain":"About The Team\n\nThe Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful experience.The Trust & Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and stakeholders.If you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust & Safety team.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful </span><a href=\"http://experience.The\" style=\"font-size: 10pt\" class=\"postings-link\">experience.The</a><span style=\"font-size: 10pt\"> Trust &amp; Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and </span><a href=\"http://stakeholders.If\" style=\"font-size: 10pt\" class=\"postings-link\">stakeholders.If</a><span style=\"font-size: 10pt\"> you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust &amp; Safety team.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1708072107075,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","description":"<div><span style=\"font-size: 16px\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","id":"6f3368c9-6e84-489c-add3-4ad1fd4b9519","lists":[{"text":"What You Will Do","content":"<li>Provide regular analysis and reports on operational performance including compliance, escalations, quality, risk, and KPI tracking to guide decision-making and devise proactive solutions</li><li>Collaborate with cross-functional teams to build, automate, and improve on the availability, integrity, accuracy, and reliability of reporting, data logging, and data pipelines to be secure and compliant</li><li>Liaise with internal and external stakeholders for regulatory and compliance reports whenever needed, including issue investigation and report verification</li><li>Create and maintain performance management dashboards, visualizations, and trackers for Operations</li><li>Develop data-driven business insights and work with cross-functional teams to identify opportunities and implement new product features or system enhancements related to Trust &amp; Safety</li><li>Identify operational weaknesses and opportunities to help improve or innovate new processes and projects to drive user and vehicle quality, customer experience, and compliance to regulatory requirements</li><li>Prepare regulatory compliance reports to ensure adherence to relevant data protection, Insurance, earnings and safety regulations</li><li>Implement and maintain a good data management system to ensure the integrity, confidentiality, and availability of trust and safety-related data.</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in analytics and operations/compliance-related role</li><li>A wizard at working on and analyzing large datasets, with the ability to translate quantitative findings into action plan, demonstrated through understanding of&nbsp; statistical methods and modeling techniques.</li><li>Strong stakeholder and project management capabilities, with great attention to detail</li><li>Resilience and ability to take initiative in our constantly-changing fast-paced environment</li><li>Strong knowledge of SQL, Python, Google Suite, and MS Excel (advanced) is required</li><li>Experience in BI tools such as Tableau, Metabase, or Data Studio is a plus</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Operations Analyst, Data Operations (Trust & Safety)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519","applyUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><span style=\"font-size: 10pt\"><b>About the team </b></span></div><div><br></div><div><span style=\"font-size: 10pt\">At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</span></div>","categories":{"department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721275390563,"descriptionPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","description":"<div><span style=\"font-size: 10pt\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","id":"03e3c5dd-2c14-4737-820e-f32b6cccf632","lists":[{"text":"What you will do:","content":"<li>Monitor and analyze key performance indicators (KPIs) to drive continuous improvement in operations.</li><li>Build and maintain strong relationships with merchant partners, promptly addressing their needs and concerns.</li><li>Train, mentor, and manage a team of onboarding specialists to ensure high performance and professional development.</li><li>Collaborate with internal teams to ensure drivers, merchants, and customers receive exceptional service.</li><li>Stay updated with industry trends and competitor activities to keep GoMart ahead.</li><li>Identify opportunities for operational efficiencies and implement best practices across the team.</li><li>Prepare routine reports and present findings as the basis of rationale and recommendations for strategic decision-making</li><li>Develop and implement strategies to enhance the onboarding process and improve merchant satisfaction.</li>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Strong analytical thinking, insights generating, and complex problem-solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds and ability to manage small team&nbsp;</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written English</li>"}],"text":"Operations Manager - GoMart","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt;\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","descriptionBodyPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","hostedUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632","applyUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632/apply"},{"additionalPlain":"About the Team\n\nOur KYC team, a subsidiary of the Data Products and Infra Team , consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Operations, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers. \nWe are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our KYC team, a subsidiary of the Data Products and Infra Team , consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Operations, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers.&nbsp;</span></div><div><span style=\"font-size: 16px\">We are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"OneKYC","allLocations":["Jakarta"]},"createdAt":1722254499146,"descriptionPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n\n","description":"<div><span style=\"font-size: 16px\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div><div><br></div>","id":"c98e554f-20cd-4d37-80b7-46794ef7bedb","lists":[{"text":"What You Will Do","content":"<li>Managing both operations and project related KYC and KYB including but not limited to managing productivity and capacity plan for ops team both in house and in vendor, daily monitoring of team’s performance, staffing and work environment</li><li>PIC for vendor management both for MP and BPO, create a robust vendor scorecard to decide whether vendor will need to be replaced or not&nbsp;</li><li>PIC for complaint handling improvement for all issues related to KYC and KYB both for new users and existing users by considering the friction in the journey and cost optimization&nbsp;</li><li>Continuous cost and benefit analysis on the whole KYC and KYB process from Ops and Business perspective including but not limited to when leading projects or in day to day BAU</li><li>Identify key risks in the current lifecycle management process for various product under GoTo entity&nbsp;</li><li>Develop and implement AML related frameworks, policies and procedures&nbsp;</li><li>Liaise with OneKYC special project in implementing process improvement to improve quality or efficiency of key work in the KYC platform or other AML processes not supported by the KYC platform</li><li>Delivery on targets and objectives in line with timelines dictated by SLA's and quality expectations</li><li>Ensure preventive and detective KYC controls and monitoring programs are in place and provide adequate coverage by working closely with risk and fraud team&nbsp;</li><li>Taking a lead in KYC teams to generate the project plan including resource plan, prioritization, budget, test strategy in improving the current process or setting up a new one&nbsp;</li><li>Have flexibility and capability upon promoting project based on the Agile methodologies and supporting Scrum Master of development team</li><li>Manages the relationship and communications with key stakeholders across the Business, AML, Compliance, Risk, and product team in or outside GoTo</li><li>PIC for all audit related matters, be it internal and/or regulatory&nbsp;</li><li>Responsible for ensuring a seamless collaboration with all counterparts both internal and external of GoTo company.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A relevant Bachelor or Master Degree from reputable University</li><li>Should have at least 8 years of experience in a financial institution and have a background in leading big scale projects and process improvement with tangible result&nbsp;</li><li>Strong sense of operational risk and regulatory risk&nbsp;</li><li>Team player (adaptable, communicative, strategic, collaborative)</li><li>Analytical mindset (able to understand the context, find the correlation between topic, and draw the conclusion)</li><li>Problem-solving (able to link the information’s to solve the problem)</li><li>Experienced in creating BRD with the minimum point of problem statement, solution to implemented, cost and benefit analysis and impact analysis&nbsp;</li>"}],"text":"Ops and Project Manager - OneKYC","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div><div><br></div>","descriptionBodyPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb","applyUrl":"https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb/apply"},{"additionalPlain":"About the team \n\nThe Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721103093996,"descriptionPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","id":"90d1d8b9-75fb-4211-8d69-99412932f5ba","lists":[{"text":"What you will do","content":"<li>Work closely with business and support units to design and execute GoTo Financial payments advocacy.</li><li>Lead external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders to advance GoTo Financial’s mission to provide accessible and safe payment products to all Indonesian users.&nbsp;</li><li>Support Compliance and Regulatory Affairs matters in GoTo Financial&nbsp; Payments Compliance operations, which includes but is not limited to business/product reporting and approval process with the regulators, and technical regulatory assessment</li><li>Create and maintain the latest update of payments regulations databases and provide/disseminate assessment on such regulations to the internal units in GoTo Financial</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law/ Economics/Management/ Accounting and International Relations. Having a master’s degree would be an advantage.</li><li>At least 4 years of mixed experience in the area of public policy/public affairs, and/or regulatory compliance and past working experience in Bank Indonesia/ Otoritas Jasa Keuangan and Public Affairs consulting firms will be an advantage.&nbsp;</li><li>Advanced level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks and proactively choose the best solutions and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including building credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"Payments Compliance PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba","applyUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba/apply"},{"additionalPlain":"\n","additional":"<div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - People & Culture","location":"Jakarta","team":"HR Information Systems","allLocations":["Jakarta","Singapore"]},"createdAt":1718958420176,"descriptionPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","description":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","id":"8fe35112-8410-4cf3-9a50-4c7287e95b57","lists":[{"text":"What You Will Do","content":"<li><b>HRIS Management &amp; Operations: </b>Operate and administer end-to-end Workday as our HRIS platform, serve as technical lead for Workday Core HCM, Talent Management, Absence, and Compensation. Provide technical support on day-to-day HR processes such as operations, payroll, performance management, and merit cycle. Act as a subject matter expert on HRIS-related inquiries and troubleshoot any technical issues that arise.</li><li><b>Process Improvement: </b>Identify opportunities to streamline HR processes using HRIS, automate manual efforts, and increase overall efficiency. Partner with cross-functional teams to identify opportunities for improvement, gather requirements, design, recommend, and implement system-driven solutions.</li><li><b>System Implementation &amp; Integration: </b>Collaborate with partners (HR and IT team) to configure and optimize HRIS modules, workflows, and integrate with other systems such as Payroll, ATS, and Finance to create seamless data flows. Lead HRIS system update and implementation of new HRIS modules, working with vendors and internal teams to plan and execute the process smoothly and successful adoption by stakeholders.</li><li><b>Report Development: </b>Develop and maintain custom reports, dashboards, and visualizations within HRIS to provide insightful HR metrics and analytics to stakeholders.</li><li><b>User Access Management and Compliance: </b>Manage user access and permissions to ensure data security and privacy compliance. Ensure HRIS compliance with relevant data protection and privacy regulations. Monitor and audit HR data to maintain accuracy, quality, and integrity, implementing necessary corrections and preventive solutions.</li><li><b>Training: </b>Provide training to HR staff and end-users on using and familiarities with the HRIS in respective to their roles.</li>"},{"text":"What You Will Need","content":"<li>Proven experience (typically 5+ years) in HRIS management and optimization.</li><li>Strong proficiency with Workday and related HR systems (Lever, Degreed, Larona, etc).Strong understanding of HR processes and workflows, with the ability to translate business requirements into HRIS solutions.</li><li>Excellent project management and problem solving skills, capable of handling multiple initiatives in a fast-paced environment.</li><li>Strong influencing skills with the ability to communicate clearly and confidently with stakeholders.</li><li>Strong managerial and leadership skills with the ability to guide, develop, and mentor team members to make things happen.</li><li>Experience communicating effectively across teams in markets across the region.</li><li><b>Preferred Qualifications: </b>Certification in Workday in one of the following modules: Core HCM, Advanced Compensation, Reporting, Talent, Performance, or Absence Management. Experience in SaaS HR system configuration. Experience with downstream system integrations such as Google Workspace, Google Cloud Platform, Workato, and JIRA/Asana.</li>"}],"text":"People Systems Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","descriptionBodyPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57","applyUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57/apply"},{"additionalPlain":"About The Team\n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div><br></div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721379671434,"descriptionPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","description":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","id":"49388333-1938-4c06-b453-911eee08c53f","lists":[{"text":"What You Will Do","content":"<li>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. </li><li>Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis</li><li>Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</li><li>Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li>"},{"text":"What You Will Need","content":"<li>At least 3 years working experience in an analytical role&nbsp;</li><li>Proficiency in multiple analytic tolls with strong knowledge of SQL and experimentation process</li><li>Effective communication skills with the ability to present financial information clearly and concisely</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Strong business acumen with a data-driven approach to problem-solving and the ability to drive initiatives independently.&nbsp;</li><li>A confident communicator in verbal and written English</li>"}],"text":"Pricing & Supply Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","descriptionBodyPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f","applyUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f/apply"},{"additionalPlain":"Our GoFood Strategy & Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. \n\nThe gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably. \n\nWhen our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">Our GoFood Strategy &amp; Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">The gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">When our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721383021327,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","description":"<div><span style=\"font-size: 9pt\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","id":"0911a6fe-475a-498f-bf48-7d492e3d04d2","lists":[{"text":"What You Will Do","content":"<li><b>Strategize, experiment, and optimize: </b>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact <a href=\"http://analysis.Execute\">analysis.</a></li><li><b><a href=\"http://analysis.Execute\">Execute</a> and collaborate: Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</b></li><li><b>Explore:</b> Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li><div><br></div>"},{"text":"What You Will Need","content":"<li>BS/MS in Business, Engineering, Computer Science, Mathematics, Economics, Statistics, or equivalent experience</li><li>At least 4 years of working experience in an analytical role</li><li>Scientist thinking process that can work in increments and exponents, coupled with hypothesis-driven mindset</li><li>Proficiency in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with strong knowledge of SQL and experimentation process</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><div><br></div>"}],"text":"Pricing & Supply Senior Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2","applyUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2/apply"},{"additionalPlain":"Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714372709159,"descriptionPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","description":"<div><span style=\"font-size: 10pt\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","id":"44117b68-3ece-40ac-91c1-920caadfe5dd","lists":[{"text":"What You Will Do","content":"<li>Design and construct scalable streaming or batch data pipelines to meet various business requirements.</li><li>Establish reliable monitoring and alerting systems to assess data pipeline performance.</li><li>Identify potential bottlenecks in the system and optimize as needed.</li><li>Manage the data science infrastructure to streamline model development and deployment.</li><li>Mentor team members by conducting code reviews and sharing knowledge.</li>"},{"text":"What You Will Need","content":"<li>Experience with streaming processing and Change Data Capture (CDC) tools such as Debezium, Flink, Kafka, etc. is necessary.</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Docker, RDBMS, and NoSQL Databases is desirable.</li><li>Proficiency in Python and SQL is expected.</li><li>Must be self-driven, with a strong sense of ownership, and capable of working independently to solve problems and develop solutions.</li><li>Project management skills to successfully drive large-scale projects from initiation to completion are needed.</li><li>Excellent communication skills, including proficiency in English, are required.</li><li>Understanding of machine learning techniques and algorithms is advantageous.</li>"}],"text":"Principal Data Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","descriptionBodyPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","hostedUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd","applyUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd/apply"},{"additionalPlain":"About the Team - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","additional":"<div><b style=\"font-size: 10pt\">About the Team</b><span style=\"font-size: 10pt\"> - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721188007441,"descriptionPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","description":"<div><span style=\"font-size: 10pt\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","id":"0197001e-f39c-4d55-b6b9-1cf247bd17b0","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutions, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li>At least 8 years of relevant experience</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Principal Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","descriptionBodyPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0","applyUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive. \n\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and </span><a href=\"http://automations.You\" style=\"font-size: 16px\" class=\"postings-link\">automations.You</a><span style=\"font-size: 16px\"> are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.&nbsp;</span></div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Gurugram"]},"createdAt":1721890257186,"descriptionPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","id":"6f2d563a-182c-4c23-8c72-9d2a4f563ed9","lists":[{"text":"What You Will Do","content":"<li>Improves code structure and architecture in service of testability and maintainability</li><li>Has in-depth understanding of multiple programming languages/paradigms, and highly proficient in one technology area, including how it interacts with the system</li><li>Leads new language/framework POC within a technical focus area, participates in the design review process, and providing constructive criticism for improvement</li><li>Is accountable for the operationalization of the tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Is accountable for ensuring that their squad has strong sets of documentations and journals of how their design and architecture evolves over time</li><li>Ensures predictability, quality &amp; throughput of their squad's delivery</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad's deliveryPrioritizes work based on understanding the trade-off between quality, tech-debt, and delivery</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: significant experience in one or many of the areas including golang/python programming, Events/stream processing framework development, engineering tooling and user facing interfaces, Kubernetes administration</li><div><br></div>"}],"text":"Principal Engineer - Cloud Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px;\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9","applyUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9/apply"},{"additionalPlain":"About the Team :\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div><span style=\"font-size: 11pt\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721116359853,"descriptionPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","id":"7c3c43e3-8b8d-48a4-a590-7754207b2d1b","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, reliable and fault tolerant platforms for one of the world's fastest growing unicorns</li><li>You will be responsible for the overall delivery and the solution architecture of the offerings your team will be working on</li><li>You will own prioritization of initiatives to maximize achievements on objectives and growth for engineering at GoTo</li><li>You should understand product engineering and have empathy with problems and pain points of Product Engineers. &amp; you will continuously contribute to make their experience better</li><li>You shall write code because you like to. You never stop wanting to get better at it</li><li>Communicate, collaborate and work effectively with product teams distributed in a global environment</li><li>You will be responsible for the overall growth, learning and happiness of your team</li><li>Is independently responsible for coaching, development, and career management for the team</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have experience in leading a team of 6-8 engineers and owning the overall delivery for the teams</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Have experience with recruitments and staffing management to help in building a sustainable team</li><li>Can take recruitment and staffing responsibilities depending to balance out the growth</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: Significant experience in one or many of the areas including Clojure programming, Stream processing framework development, engineering tooling and user facing interfaces</li>"}],"text":"Principal Software Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt;\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b","applyUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b/apply"},{"additionalPlain":"About the Team\n\nOur Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1715060912791,"descriptionPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"426f18b4-739e-4da0-a74b-446c349c0a31","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Collaborate with cross functional teams (Mobile, DevOps, UX, QA etc.) on execution and delivery</li><li>Partner with the team to define and execute the feature roadmap</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"What You Will Need","content":"<li>Should have at least 7 years of hands-on experience in designing, developing, testing and deploying applications at scale</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Principal Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31","applyUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719211012411,"description":"","descriptionPlain":"","id":"fc7c3413-6c4f-42bd-a048-70387bd490a4","lists":[{"text":"What you will do:","content":"<li>Process Analysis and Assessment: 1. Conduct comprehensive assessments of existing business processes to identify inefficiencies, bottlenecks, and areas for improvement. 2. Gather and analyze data to understand process performance and identify root causes of issues. 3. Develop process maps, flowcharts, and other documentation to visualize current state processes.</li><li>Improvement Strategy Development: Collaborate with stakeholders to design and develop strategies for process improvement, focusing on enhancing efficiency, quality, and customer satisfaction.</li><li>Implementation of Improvements: 1. Lead cross-functional teams in the implementation of process improvements, ensuring alignment with business goals and objectives. 2. Develop &amp; monitor detailed project plans, timelines, and milestones to guide improvement initiatives.</li><li>Change Management and Communication: Drive change management efforts &amp; communicate effectively to ensure smooth adoption of new processes and practices.</li><li>Performance Monitoring and Reporting: 1. Establish key performance indicators (KPIs) to measure the effectiveness of process improvements. 2. Conduct post-implementation reviews to assess the impact of changes and identify further improvement opportunities.</li><li>Continuous Improvement Culture: Provide mentorship and guidance to stakeholders on process improvement methodologies and tools.</li>"},{"text":"What you will need:","content":"<li>Bachelor's degree in Business Administration, Industrial Engineering, Operations Management, or a related field. A Master's degree is preferred.</li><li>Proven experience in business process improvement, process engineering, or related <a href=\"http://roles.Strong\" class=\"postings-link\">roles.</a></li><li>Strong knowledge of process improvement methodologies (e.g., Lean, Six Sigma, Kaizen).</li><li>Excellent analytical and problem-solving skills.</li><li>Exceptional project management skills, with experience leading cross-functional teams.</li><li>Strong communication and interpersonal skills, with the ability to influence and drive change.</li><li>Proficiency in process mapping and analysis tools (e.g., Visio, Lucidchart).</li><li>Ability to manage multiple projects and priorities in a fast-paced environment.</li>"},{"text":"Preferred Skills:","content":"<li>Fluent in English&nbsp;</li><li>Experience with data analysis tools (e.g., Excel, Tableau, Power BI).</li><li>Knowledge of change management principles and practices.</li><li>Familiarity with ERP and CRM systems, especially Salesforce</li><li>Experience in training and development related to process improvement.</li>"}],"text":"Process Improvement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4","applyUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4/apply"},{"additionalPlain":"About The Team\n\nGoTo Procurement  Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.\n\nAs a team, we are not only concerned about the company but also the professional and personal growth & aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">GoTo Procurement&nbsp; Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we are not only concerned about the company but also the professional and personal growth &amp; aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things</span></div>","categories":{"department":"HoldCo - Finance","location":"Jakarta","team":"Procurement","allLocations":["Jakarta"]},"createdAt":1721729730710,"descriptionPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","id":"c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","lists":[{"text":"What Will You Do","content":"<li>Lead and execute the Vendor Selection process to ensure that the company is getting what it really needs as well as the best deal in the market, following GoTo Procurement Procedure while adhering to relevant Policies and Procedures within the organization and collaborating with the relevant stakeholders and Subject Matter Expert (SME) to support comprehensive evaluation. The vendor selection process will be for both Tactical and Strategic bidding and aim for cost optimization targets and ensure the proper documentation to establish transparency and accountability</li><li>Drive cost optimization initiatives to support organization operating cost optimization through the execution of Procurement activities, including mitigation of any relevant risks within the Source-to-Pay process and supply chain.&nbsp;</li><li>Owning the Source-to-Pay process by ensuring a seamless transition throughout the steps, starting from capturing business needs up to Vendor Payment</li><li>Increase Procurement’s technology and platform utilization and target for SLA optimization and Sourcing Quality</li><li>Develop a Sourcing competencies framework as part of people development within the Procurement Sourcing organization</li><li>Build the right vendor market and network as well as internal stakeholders, to support the collaborations within Procurement processes</li><li>Lead and collaborate Vendor Value Creation Program together with Critical/Valued vendors to deliver innovation, better speed to market, productivity, asset utilization, sustainability, etc.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Bachelors of business, supply chain management, or any other related field. Preferably has been working in Procurement too</li><li>At least 2 years in procurement areas, preferably from multinational companies</li><li>Strong business and commercial mindset</li><li>Excellent negotiation, organizational, and collaboration skills</li><li>Excellent interpersonal and communication skills</li><li>Excellent project management skills</li><li>Advanced in verbal and written English proficiency</li>"}],"text":"Procurement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","descriptionBodyPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","applyUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274/apply"},{"additionalPlain":"About the Team\n\nThe Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.\n\nWe have helped simplify payments for over 750,000 merchant partners, over  1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.</div><div><br></div><div>We have helped simplify payments for over 750,000 merchant partners, over&nbsp; 1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1720599307040,"descriptionPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","description":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","id":"83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","lists":[{"text":"What You Will Do","content":"<li>Conduct merchant research and analyze user data to identify trends and pain points.</li><li>Working with Business Intelligence teams, writing queries and learning to set up product metric tracking dashboards&nbsp;</li><li>Help summarize merchant interviews as insights</li><li>Collaborate with product managers and designers to define product requirements.</li><li>Develop and present product recommendations based on data analysis.</li><li>Assist with creating product prototypes and user testing.</li><li>Stay up-to-date on industry trends and competitor analysis.</li>"},{"text":"What You Will Need","content":"<li>Strong analytical skills with proficiency in data analysis tools, candidates with experience will be preferred</li><li>The ability to write SQL queries is strongly preferred</li><li>Excellent communication and presentation skills.</li><li>A passion for product development and a keen eye for detail.</li><li>Familiarity with the Indonesian payments landscape is a plus.</li>"}],"text":"Product Analyst Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","descriptionBodyPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","applyUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8/apply"},{"additionalPlain":"About The Team\n\nThis vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.  \n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>This vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.&nbsp;&nbsp;</div><div><br></div>","categories":{"department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1718084687109,"descriptionPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","description":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","id":"a1ebb8d4-0af0-4707-9efb-8f52aa781c44","lists":[{"text":"What You Will Do","content":"<li>Help define the roadmap, goals, and vision for the product experience</li><li>Work with design leads, product heads, marketing and engineers to build/improve user experience and ways of working towards that vision</li><li>Manage projects, solve complex problems, and enable your team to deliver delightful solutions that drive impact</li><li>Build systems for design documentation &amp; help establish processes to ensure seamless collaboration</li><li>Mentor and coach a team of designers, improve stakeholders grasp and application of design thinking</li><li>And most importantly, make sure your team is engaged well and building things that make them successful</li>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in product design, but still willing to learn more about product research</li><li>Proficiency in all areas of digital product design; visual design, user experience design, user research prototyping, advocacy and building showcases. Additional exposure to motion, sound, video and other craft are welcome</li><li>Ability to draw insights from both qualitative &amp; quantitative data, and further identify problem areas to work on.</li><li>Ability to design, advocate and prioritize user research with our research team</li><li>Knowledge in design fundamentals, such as design thinking frameworks, HCI principles, and being able to take on a structured approach in solving problems</li><li>Excellent organizational, project management, and collaboration skills to manage a wide range of stakeholders</li>"},{"text":"","content":"<li><br></li>"}],"text":"Product Design Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44","applyUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44/apply"},{"additionalPlain":"About the Team\n\nThe Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. \n\nWe’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers. \n\nThe Loyalty, Incentives & Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more. \n\nWe are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .\n\n\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. </div><div><br></div><div>We’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers.&nbsp;</div><div><br></div><div>The Loyalty, Incentives &amp; Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more.&nbsp;</div><div><br></div><div>We are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .</div><div><br></div><div><br></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718798053606,"descriptionPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","id":"e407433b-435a-4607-89bd-5faf51cf622e","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of a senior product designer, and follow the predefined process set forth by the team</li><li>Able to comprehend the product briefs and be able to present the ideas/solutions to the team under the supervision of the product design lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Define end-to-end wireframe and wireflow for features using standard wireframing tools</li><li>Document the design process for each feature, such as research findings, ideations, usability tests, release, and monitor the impact after the product release</li><li>Contribute to the team cadence discussion and make occasional short presentations to the team, as well as present team’s updates if needed</li><li>Proactively seek/give feedback from other stakeholders to make sure concepts are meeting the intended project goal</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of relevant experience in the product design industry</li><li>Familiar with data and can identify problem areas, further map out the user journey, and break the problems into smaller chunks</li><li>Use basic analytics tools to gather customer data (funnel)&nbsp;</li><li>Possess a good knowledge of design fundamentals, such as design thinking framework and other frameworks to develop products</li><li>Able to sketch the ideas into wireframes, learn how to make wireflow, and do wireframing for well-defined features</li><li>Good knowledge of the tools, such as Overflow, Miro, Sketch, Figma, or similar ones that are widely used by Product Designers</li><li>Knowledge of design validation, either through quantitative or qualitative research</li><li>Preferably some knowledge of service design and experience with working on mobile app design</li>"}],"text":"Product Designer - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e","applyUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e/apply"},{"additionalPlain":"About The Team\n\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718166115141,"descriptionPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","description":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","id":"b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirements and the impact of each feature, as well as the go-to-market strategy to ensure adoption of the features</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in product management experience</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Growth","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","applyUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba/apply"},{"additionalPlain":"About The Team\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. \n\nThe Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.\n","additional":"<div><b>About The Team</b></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology.&nbsp;</div><div><br></div><div>The Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.</div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719305116114,"descriptionPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","id":"6f05ee4a-fa49-4aca-8990-c6607cd7cf09","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched&nbsp;</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirement and the impact of each feature as well as the go to market strategy to ensure adoption of the features.&nbsp;</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of total experience, with 2-3 years experience specifically in product management</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09","applyUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09/apply"},{"additionalPlain":"About The Team\nWork hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Work hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721026583842,"descriptionPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","id":"92f4b266-849a-42f2-b7e0-859360a003d8","lists":[{"text":"What You Will Do","content":"<li>Develop and own end-to-end project and program plans that outline scope, goals, deliverables, required resources, and timelines&nbsp;</li><li>Monitor progress of projects and programs to highlight plan deviations,, resolve issues and propose corrective actions to remove implementation blockers</li><li>Oversee and synergise multiple projects to ensure prompt completion within scope, and within budget</li><li>Work closely with internal and external stakeholders from cross-functional teams to assess feasibility of initiatives, develop the scope, and deliverables</li><li>Act as a point of escalation for project and program initiatives’ issues, mediate issues, and ensure stakeholder’s expectations are met</li>"},{"text":"What This Role Needs","content":"<li>At least 3 years of work experience in the financial industry, having worked in mid to large-scale cross-functional projects and/or programs, particularly in lending (consumer and/or loan lending products, such as cash loan, buy now pay later, merchant financing, vehicle financing, etc)</li><li>Well-versed in speaking &amp; writing in English, Bahasa Indonesia; Mandarin is a plus</li><li>Comfortable in fronting conversations with senior leaders and C-suite leaders</li><li>Able to work under pressure with strict implementation timelines</li><li>Possess a strong ability to analyze data and generate insights to value-add to the projects/programs</li><div><b>Soft Skills</b></div><li>Stakeholder management skills</li><li>Sharp business acumen</li><li>Attention to details</li><li>Time management</li><div><b>Hard Skills</b></div><li>Project / ProgramManagement Skills, ideally CAPM certified will be advantageous</li><li>Six Sigma Skills, ideally Six Sigma GreenBeltcertified will be advantageous</li><li>Knowledgeable about financial industry laws &amp; regulations &amp; being compliant at all times</li><li>Good working knowledge of Project Management tools like Jira, Lark and Google Suites</li><li>Knowledge about e-commerce / transport industries is a plus</li>"}],"text":"Program Manager, Consumer Lending - #10310","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","descriptionBodyPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8","applyUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8/apply"},{"additionalPlain":"About the Team\nOur KYC team, a subsidiary of the Payment Platform Team, consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Product, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers. \nWe are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><span style=\"font-size: 16px\">Our KYC team, a subsidiary of the Payment Platform Team, consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Product, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers.&nbsp;</span></div><div><span style=\"font-size: 16px\">We are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"OneKYC","allLocations":["Jakarta"]},"createdAt":1722254311646,"descriptionPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n","description":"<div><span style=\"font-size: 16px\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div>","id":"22a1f73e-1fed-464e-a66c-72139d289c14","lists":[{"text":"What You Will Do","content":"<li>Closely liaise with Ops team to address pain point and issues in the ops process or issues that might triggered customer complaints, and come up with solution to address the issue and oversee the implementation and measure result</li><li>Together with Product &amp; Compliance team, refine all the existing processes to achieve company goals and ensure that user journey complies with country regulations at all times</li><li>Initiate a process review and benchmark to come up with solutions on how best to create a seamless KYC and KYB process to onboard “good user”</li><li>Continuous cost and benefit analysis on the whole KYC and KYB process from Ops and Business perspective including but not limited to when leading projects or in day to day BAU&nbsp;</li><li>Work closely with the Fraud team to identify trends of fraud patterns during KYC and KYB submission, figure out solutions to address the issue, collaborate with the product team in delivering the solution from testing to production deployment, from UAT to sanity testing&nbsp;</li><li>Work closely with Product team to do the continuous review and refine User Interface and User Experience flow throughout the whole KYC and KYB process&nbsp;</li><li>Drive all the initiatives and discussions related to KYC and KYB process including but not limited to, new projects, impact, issue and target by closely collaborating with internal and external counterpart&nbsp;</li><li>Lead the initiative for complaint handling related KYC and KYB process not only related to newly implemented process but also to address issue that might happen from incorrect ops process</li><li>Lead eKYC solution with external clients from start to finish and continue with maintaining the relationship with external clients to ensure a seamless integration and create a seamless user journey.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A relevant Bachelor or Master Degree such as Business Administration, Management, Computer Science, etc. and PMP or PMI certification is a plus</li><li>Minimum of 5 years of experience as a Project Manager and have a background in leading big scale, multiple projects and process improvement with tangible result</li><li>Should have a working experience in a financial institution is a plus</li><li>Strong sense of operational risk and regulatory risk&nbsp;</li><li>Team player (adaptable, communicative, strategic, collaborative)</li><li>Analytical mindset (able to understand the context, find the correlation between topic, and draw the conclusion)</li><li>Problem-solving (able to link the information’s to solve the problem)</li><li>Experience in creating BRD with the minimum point of problem statement, solution to implemented, cost and benefit analysis and impact analysis&nbsp;</li><li>Proficiency in English both active and passive is a must</li>"}],"text":"Project Manager - OneKYC","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div>","descriptionBodyPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n","hostedUrl":"https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14","applyUrl":"https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14/apply"},{"additionalPlain":"About the Team\n\nOur Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720752364065,"descriptionPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","id":"20554643-fae8-4082-8797-7d5fd44db8b0","lists":[{"text":"What You Will Do","content":"<li>Develop and run complex analysist to support business decision</li><li>Design and develop dashboards to track business and product performance</li><li>Leverage data from dashboards as well as other sources to derive insights as a basis of rationale and recommendations in decision-making processes</li><li>Running a project management for multiple projects at different stages &amp; complexity</li>"},{"text":"What You Will Need","content":"<li>At least 2-3 years of experience in a business analytics or business intelligence role at a tech company</li><li>End-to-end the problem-solving mindset</li><li>Strong communication and project management skills</li><li>Strong proficiency in SQL, Microsoft Excel, and PowerPoint</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"Project Manager - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0","applyUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0/apply"},{"additionalPlain":"About the Team\n\nInsurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721362323598,"descriptionPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","id":"8906c3d0-c77f-4a0a-8f25-8b738515ede3","lists":[{"text":"What You Will Do","content":"<li>Attend daily standup meetings, sprint planning, and backlog reviews</li><li>Communicate project status to internal and external teams promptly</li><li>Analyze and estimate product features from a testing perspective</li><li>Ensure software quality by adopting best practices in software development</li><li>Design, develop, and execute automation scripts using open-source tools</li><li>Identify, record, document, and track bugs thoroughly</li><li>Perform thorough regression testing when bugs are resolved</li><li>Collaborate with product managers to clarify feature requirements and ensure comprehensive test coverage</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of experience in professional testing</li><li>Strong understanding of unit testing concepts and problem-solving using online resources</li><li>Deep knowledge of Manual &amp; Automation test methodologies and principles</li><li>Capability to create testing scenarios/scripts using test management tools</li><li>Experience in Mobile and API Testing in both manual &amp; automation contexts</li><li>Proficiency with automation tools like Jira, Selenium, RestAssured, ​​TestNg using Java (preferably), Postman, Gitlab, Kafka</li><li>Good understanding of logging mechanisms, messaging services, and pipelines</li><li>Experience working with the AGILE process methodology and strong interpersonal communication skills for collaboration with remote teams</li>"}],"text":"QA Engineer - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3","applyUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717052781419,"descriptionPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","description":"<div><span style=\"font-size: 10.5pt\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","id":"4ba1eea8-feed-4843-be2e-93a21f0eadb1","lists":[{"text":"What Will You Do","content":"<li>Perform exploratory data analysis using SQL and present interesting findings to business stakeholders to drive business and strategic decisions</li><li>Design and analyze experiments to improve service quality and quantity</li><li>Build and maintain self-serve data products such as dashboards (Looker &amp; Tableau) and tables to reduce time to insights</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Should have at least 2-3 years of practical experience in <a href=\"http://SQL.Prior\" class=\"postings-link\">SQL.</a></li><li><a href=\"http://SQL.Prior\" class=\"postings-link\">Prior</a> experience with applied statistics, experimental design is a <a href=\"http://plus.Able\" class=\"postings-link\">plus.</a></li><li><a href=\"http://plus.Able\" class=\"postings-link\">Able</a> to tell a coherent data narrative using visualization tools and able to set best practices in data visualization to convey a product insight through impactful <a href=\"http://graphs.Proven\" class=\"postings-link\">graphs.</a></li><li><a href=\"http://graphs.Proven\" class=\"postings-link\">Proven</a> ability to recognize business needs and ability to communicate with multiple stakeholders including PMs, business and <a href=\"http://operations.Balance\" class=\"postings-link\">operations.</a></li><li><a href=\"http://operations.Balance\" class=\"postings-link\">Balance</a> attention to detail with swift execution.</li><div><br></div>"}],"text":"Region Analytics Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","descriptionBodyPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1","applyUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1/apply"},{"additionalPlain":"About The Team\n\nAs an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">As an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713428751727,"descriptionPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","description":"<div><b style=\"font-size: 10pt\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","id":"0489939a-c571-4d5f-adaa-95ceac8912c5","lists":[{"text":"What You Will Do: ","content":"<li>Responsible for completed orders and profit and loss target achievement</li><li>Provide analytics to support operations team such as Supply Reliability, Fraud rules, Driver’s Engagement etc. at the regional level</li><li>Deploy defined strategies from operations perspective during the process of establishing the new area of service as well as optimizing existing area</li><li>Ensure SOP and legal compliances in the region</li><li>Support Regional Operation Head to oversee all districts and branches operations</li><li>Analyze driver states &amp; measure efficiency of various driver badges to generate more high quality drivers in the region</li><li>Support Regional Operation Head in product changes roll out in the region</li>"},{"text":"What You Will Need:","content":"<li>Having at least 5 years experience in supply chain, preferably at the managerial level and from Multi National Company or similar experience in the Ride Hailing/ On Demand Service Industry</li><li>Strong analytical thinking and problem solving skills using various improvement tools and methods (preferably have prior exposure to SQL)</li><li>Having good understanding about supply and demand planning</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Lead team / project as well as persuade stakeholders to ensure speed &amp; quality of project / initiative</li><li>Proficiency in to converse in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Region Operations Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","descriptionBodyPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5","applyUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718002291914,"descriptionPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","description":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","id":"f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","lists":[{"text":"What You Will Do","content":"<li>Monitor and analyze transactions and user activities to detect suspicious patterns and potential fraud.</li><li>Conduct thorough investigations of suspected fraud cases and recommend control actions.</li><li>Develop and implement strategies to mitigate fraud risks across the platform.</li><li>Collaborate with product, engineering, and operations teams to enhance fraud prevention measures.</li><li>Prepare detailed reports on fraud incidents, including root cause analysis and actionable recommendations.</li><li>Provide regular updates to senior management on fraud trends, risks, and mitigation efforts.</li><li>Stay updated on the latest fraud trends, tools, and best practices to continuously improve detection and prevention strategies.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Finance, Accounting, Business, Computer Science, or a related field.</li><li>2+ years of experience in fraud risk management or a related role.</li><li>Strong analytical and problem-solving skills, with proficiency in data analysis tools (e.g. SQL, Python, Excel) and experience with visualization tools (e.g. Tableau, DataStudio)</li><li>Excellent communication and interpersonal skills.</li><li>Ability to work independently and as part of a team in a fast-paced environment.</li><li>Strong attention to detail and commitment to accuracy.</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Risk Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","descriptionBodyPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","applyUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710738954272,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"60d37414-287e-4552-a0d0-accf1737d0ce","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>3-4 years of related payment risk experience, preferably on the acquiring side and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business side</li>"}],"text":"Risk Analyst - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce","applyUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce/apply"},{"additionalPlain":"In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1704856901936,"description":"","descriptionPlain":"","id":"5611e062-e094-4da3-ab1c-75c85cf62194","lists":[{"text":"What You Will Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volumes of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutions, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers&nbsp;</li>"},{"text":"What you will need","content":"<li>3+ years of experience developing ML solutions</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Risk Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194","applyUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713334327811,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"a61cda6c-82fd-4daf-aabf-3db91e01684f","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>5-8 years of related payment risk experience, preferably on the mobile apps and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business sid</li>"}],"text":"Risk Manager - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f","applyUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715584452832,"descriptionPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","description":"<div><b style=\"font-size: 16px\">About the team:</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","id":"d6ac496c-e0ad-4669-b594-ede9bf8d55f9","lists":[{"text":"What you will do:","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed,</li><li>Resolve account issues and complaints,</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis,</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments,</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation,</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients,</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms.</li>"},{"text":"What you will need:","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area,</li><li>A minimum of 3 years of experience in business management, sales, or project management is mandatory. </li><li>Prior experience in e-commerce and managing key accounts will be a plus point,</li><li>Fluency in both Bahasa and English is required,Able to multitask, prioritize, and manage time efficiently,</li><li>Ability to negotiate, persuade and influence others,</li><li>Excellent interpersonal, communication, presentation and analytical skills,</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills,</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners.</li>"}],"text":"Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the team:</b></div><div><span style=\"font-size: 16px;\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","descriptionBodyPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9","applyUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9/apply"},{"additionalPlain":"The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood campaigns.\n\nIn the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales team.When our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their efficiency.\n\nIn our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood </span><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">campaigns.</span></a></div><div><br></div><div><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales </span><a href=\"http://team.When\" class=\"postings-link\"><span style=\"font-size: 10pt\">team.When</span></a><span style=\"font-size: 10pt\"> our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their </span><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">efficiency.</span></a></div><div><br></div><div><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Excellence","allLocations":["Jakarta"]},"createdAt":1714365620212,"descriptionPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","description":"<div><span style=\"font-size: 10pt\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","id":"f39be622-e287-41df-bcb2-7389478a1be4","lists":[{"text":"What you will do","content":"<li>Oversee the performance tracking and monitoring of the whole Enterprise Sales Team</li><li>Ensure that the Enterprise Sales team has all the data they need to achieve their target for all KRs</li><li>Act as a consultant and discuss with the EKAMs on the business needs/challenges that their merchants are facing</li><li>Provide data and data driven insights to EKAMs to help address said challenges</li><li>Assist in performing periodical business analysis, tailored to each merchant based on their business needs</li><li>Assist in the daily tasks and smooth operations of Enterprise Sales Support</li><li>Liaise with HO team for merchant x sales account management, target, tracker, etc</li><li>Liaise with other teams (e.g. BI, Salestech) when there is new KRs / data point that needs to be analysed</li><div><br></div>"},{"text":"What you will need","content":"<li>At least 2 years of relevant experience in data analytics&nbsp;</li><li>Good business acumen, able to develop analysis with good storyline and flow</li><li>Proficient in SQL, Google BigQuery and the reporting thereof is an advantage</li><li>Proficient in handling large amount of data using tools/softwares such as google sheet, metabase and datastudio</li><li>Great communication and understanding skill, able to explain technical terms in simple, understandable manner</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>High interest and eagerness to analyse different parts of businesses to help achieve growth</li><li>Clear understanding of Gojek services and the tech industry</li><div><br></div>"}],"text":"Sales Support Senior Associate, Enterprise","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","descriptionBodyPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4","applyUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4/apply"},{"additionalPlain":"About The Team\n\nOur Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1720004794044,"descriptionPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","id":"bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","lists":[{"text":"What You Will Do","content":"<li>Identify areas of business growth by structuring problem statements and forming hypotheses</li><li>Query and process large amounts &amp; complex data sets of our customers’ behavior, usage patterns, statistical trends, and funnel performance&nbsp;&nbsp;</li><li>Synthesize actionable insights and solutions from the data analysis</li><li>Own and drive the proposed initiatives to achieve business objectives</li><li>Visualize and communicate findings in an easy-to-understand, concise, and clear format</li><li>Experiment with the growth initiatives and continuously iterate to find areas for improvements</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience working in a data-driven environment, previous experience in the tech industry is a bonus</li><li>Proficient in data query, data processing, and charting to synthesize actionable insights from large sets of complex data</li><li>Strong structured problem-solving abilities to identify issues, form hypotheses, and generate recommendations</li><li>Ability to create and execute experimentation plans or A/B testing on key growth initiatives&nbsp;</li><li>Excellent project and stakeholder management skills to ensure all planned initiatives are met on high quality and on time</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Ability to learn new things and adapt your priorities quickly within a fast-paced environment</li>"}],"text":"Savings Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","descriptionBodyPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","applyUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1698657930091,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"376aefd9-6d6c-4e57-8040-a3b0dd416d26","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2 to 4 years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26","applyUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719471574933,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2-4+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","applyUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Consumer Experience","allLocations":["Bengaluru"]},"createdAt":1716277072995,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"0169bd4d-f352-4162-8e8e-2c09df5b8db4","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Growth","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4","applyUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788743352,"descriptionPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","id":"08aa1472-d91f-4c5d-b5e0-e88163943bcd","lists":[{"text":"What You Will Do","content":"<li>Design, implement, and maintain the company’s IT infrastructure, ensuring scalability, reliability, and performance.</li><li>Manage servers, networks, databases, and cloud services to support business operations and growth.</li><li>Develop and implement comprehensive cybersecurity strategies to protect the company’s assets and data.</li><li>Conduct regular security assessments, vulnerability scans, and penetration testing to identify and mitigate risks.</li><li>Oversee the installation, configuration, and maintenance of hardware and software systems.</li><li>Ensure data integrity and availability through effective backup and disaster recovery planning.</li><li>Develop and enforce IT policies and procedures to ensure security, compliance, and efficient operations.</li><li>Ensure compliance with relevant regulations and industry standards.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, Information Technology, or a related field. A Master’s degree or relevant certifications (e.g., CISSP, CISM) is a plus.</li><li>Minimum of 7 years of experience in IT infrastructure management, cybersecurity, or a related role, with at least 3 years in a leadership position, preferably in the cryptocurrency or fintech industry.</li><li>Strong understanding of IT infrastructure, network administration, and cybersecurity practices.</li><li>Proven track record of developing and implementing successful IT and security strategies.</li><li>Excellent analytical, problem-solving, and organizational skills.</li><li>Strong leadership, communication, and interpersonal skills.</li><li>Preference qualifications in high-frequency trading</li>"}],"text":"Security and System Infra Manager (CISSP) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd","applyUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd/apply"},{"additionalPlain":"About the Team\n\nThe Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial <a href=\"http://platforms.It\" class=\"postings-link\">platforms.It</a> is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719832381686,"descriptionPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","id":"9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","lists":[{"text":"What You Will Do","content":"<li>Perform security design on applications (web, mobile) and infrastructures (cloud, on-premise)</li><li>Perform security code review (manual, automated) on applications and infrastructures</li><li>Ensure applications and infrastructures are secure by design, follow secure design principles, and adopt secure coding practices</li><li>Identify security gaps and vulnerabilities, and propose appropriate controls and remediations</li><li>Propose solutions to wide-ranging security problems</li><li>Raise security awareness among the Product, Engineering, and Infrastructure team by conducting security training, and having regular security discussions</li><li>Bridge communication between the broader Information Security team with the Product, Engineering, and Infrastructure team</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, or a related field</li><li>Minimum 3 years of experience in Software Engineering, preferably on web and mobile application</li><li>Minimum 3 years of experience in Information Security, preferably in application and cloud security</li><li>Good knowledge of common secure design principles and secure coding practices</li><li>Good knowledge of common adversarial techniques, tactics, and procedures&nbsp;</li><li>Ability to learn new things quickly and independently</li><li>Ability to communicate effectively, preferably in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Security Engineering Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","descriptionBodyPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","applyUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12/apply"},{"additionalPlain":"About the Team\n\nThe Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.\n\nCTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.</div><div><br></div><div>CTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721369663762,"descriptionPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","id":"767d8980-5402-488d-b62c-222c0b4a0bfc","lists":[{"text":"What You Will Do","content":"<li><b>Observe</b>: Monitor the surface, deep, darkweb, and listen to your intelligence-sharing circles.</li><li><b>Analyze</b>: Through understanding of the internal landscape assess the (predicted threat). Support the incident response investigation, when needed.</li><li><b>Disrupt</b>: disrupt the effectiveness of the threats by various means.</li><li><b>Report</b>: Communicate timely, simply, and effectively the threat and key recommendations.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, Networking, and Cyber Security.</li><li>Working experience with one or multiple categories of tools (open source or commercial): Link Analysis Tools, Threat Modeling Tools, (Threat) Feed Aggregators, Threat Intelligence Platforms (TIP’s), Digital Risk Protection platforms, Malware Sandboxes, SOAR, SIEM or EDR.</li><li>5-7 Years of working experience (strong mid-level or senior in cyber security), relevant degree (bachelor or higher), or reputable industry certification (e.g.: ISC2, GIAC, Offsec, EC Council) preferred.</li><li>Extensive working experience in the CTI field is preferred, candidates from the following affiliated fields are alternatively also preferred: SOC, Vulnerability Management (VAPT), Penetration Testing, or Digital Forensics Incident Response (DFIR).</li><li>Possess critical thinking and problem-solving skills.</li><li>Leadership, experience in mentoring junior members, and stakeholder management skills are a must. You will be leading multiple important initiatives across the teams/companies.</li><li>Proficiency in English and Indonesian, both in written and oral form.</li><li>Outstanding reporting skills: content, delivery, clarity, brevity, and presentation.</li>"}],"text":"Senior Cyber Threat Intelligence Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt;\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","descriptionBodyPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc","applyUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719213882004,"descriptionPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","description":"<div><b style=\"font-size: 10pt\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","id":"1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","lists":[{"text":"What you will do","content":"<li><b>Design, build, and maintain the ETL </b>from various sources into the data mart; Troubleshoot and resolve data-related issues, including data discrepancies, anomalies, and performance bottlenecks</li><li>End to end data project ownership and collaboration with cross-functional teams to understand data requirements and design data models that support the organization's single version of truth</li><li>Ensure the quality, accuracy, and reliability of our data by implementing data validation checks and error handling mechanisms</li><li>Develop and customize Tableau/Google Sheet/Looker studio reports that provide actionable insights to stakeholders</li><li>Create and maintain documentation related to data structures, processes, and transformations for future reference</li>"},{"text":"What you will need","content":"<li>4 years of experience in <b>Data Analyst/BI Analyst/</b>BI Engineer</li><li>Advance knowledge of <b>SQL </b>and Python</li><li>Able to lead a small team also can work as a individual contributor</li><li>Hands on experience with data visualization Tableau Looker studio/Google Sheet</li><li>Strong analytical and problem-solving skills, with keen attention to detail</li><li>Excellent communication skills (English is a must) to collaborate with technical and non-technical stakeholders</li><li>Having a people manager experience is a plus</li>"}],"text":"Senior Data Analyst (Analytics Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","descriptionBodyPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","applyUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264696268,"descriptionPlain":"\n","description":"<div><br></div>","id":"6d8ebb73-2348-423d-847e-b8a8408ac1ed","lists":[{"text":"What You Will Do","content":"<li>Gather business requirements to support BI projects.</li><li>Explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What you will need ","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Senior Data Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed","applyUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed/apply"},{"additionalPlain":"Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719472943608,"descriptionPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","description":"<div><span style=\"font-size: 10pt\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","id":"90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","lists":[{"text":"What You Will Do","content":"<li>Design, build, and maintain data streaming solutions.</li><li>Troubleshoot and resolve data-related issues, including discrepancies, anomalies, and performance bottlenecks.</li><li>Ensure scalability and reliability of the data streaming platform.</li><li>Collaborate with data engineers, data scientists, and other stakeholders to understand requirements and provide tailored streaming solutions.</li><li>Monitor and optimise performance to ensure low latency and high throughput.</li><li>Perform regular maintenance tasks, including upgrades and patches.</li><li>Document design, implementation, and maintenance processes.</li><li>Stay updated with the latest advancements in data streaming technologies.</li>"},{"text":"What You Will Need","content":"<li>3 - 6 years of experience as a Data Engineer.</li><li>Strong programming skills in Java.</li><li>Hands-on experience in real-time streaming with Apache Flink.</li><li>Experience working with Apache Kafka and Kubernetes.</li><li>Experience working with any cloud platform and NoSQL database.</li><li>Strong analytical and problem-solving skills, with keen attention to detail.</li><li>Excellent communication skills for collaborating with technical and non-technical stakeholders.</li><li><b>Good to have: </b>Programming in Go/Python, IAC using Terraform, Batching ETL and exposure to open data lakehouse architecture is a plus</li><li><br></li>"}],"text":"Senior Data Engineer - Data Streaming","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","descriptionBodyPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","applyUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720774001435,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"976d0171-5a06-43e2-9ec6-e0b45345c6fd","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd","applyUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd/apply"},{"additionalPlain":"About The Team\nThe GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><span style=\"font-size: 10pt\">The GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1684915963454,"descriptionPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","description":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","id":"a539cdc1-109f-48e8-9b24-1a831b735f01","lists":[{"text":"What Will You Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volume of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers</li>"},{"text":"What You Will Need","content":"<li>6+ years of experience developing ML solutions, 2-3 years of <b>fraud risk experience in account takeover, scam, and abuse</b></li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt;\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","descriptionBodyPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01","applyUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1713852044349,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"34f6146a-c482-407c-a31c-72ac9bb90a7c","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>Analyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist - Marketplace (Singapore)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c","applyUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1705993404249,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"86673189-b5e2-4ace-b1a3-5ab20f14d84d","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist (India)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d","applyUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707210044551,"descriptionPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","description":"<div><span style=\"font-size: 10pt\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","id":"c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","lists":[{"text":"What You Will Do","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What You Will Need","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li>"}],"text":"Senior Data Warehouse Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","descriptionBodyPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","applyUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69/apply"},{"additionalPlain":"About The Team\n\nOur Data Warehouse team is based in Jakarta & Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nOur team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data Warehouse team is based in Jakarta &amp; Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1713498805305,"descriptionPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","description":"<div><span style=\"font-size: 10pt\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","id":"2b430ba4-210e-4db6-a63e-c11459a0304f","lists":[{"text":"What Will You Do?","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What Do You Need? ","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li><li>You’re passionate about your customers and always bring questions back to what will serve them best</li>"}],"text":"Senior Data Warehouse Engineer - India","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt;\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","descriptionBodyPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f","applyUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f/apply"},{"additionalPlain":"About the Team\n\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719199384298,"descriptionPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"905d4e32-1699-4fcc-96b3-aa6aa0b462cb","lists":[{"text":"What You Will Do","content":"<li>Analyze database performance data to identify bottlenecks and implement optimizations to enhance system efficiency and reliability</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li><li>Design and develop custom tools and utilities to facilitate various database operations, leveraging programming languages such as Ruby, or Golang</li><li>Ensure database security best practices are implemented and maintained, including access control, encryption, and compliance with relevant regulations</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Continuously evaluate database infrastructure usage and performance metrics to identify opportunities for cost optimization</li><li>Benchmarking tests to evaluate the impact of configuration changes on database performance. This helps in identifying optimal parameter values and fine-tuning configurations for different types of workloads.</li><li>Tuning database configuration parameters to optimize database performance for the application</li>"},{"text":"What You Will Need","content":"<li>8+ years experience as a DBA Engineer in managing databases for a large production environment</li><li>Expert in various database management systems (MySQL/PostgreSQL, Redis, MongoDB, and Elastic Search), and techniques for optimizing databases and understanding the basic cloud platform (AWS or GCP)</li><li>Advanced skills in a programming language like Ruby or Golang, and possess deep expertise in shell scripting</li><li>Excellent experience with Linux is required and expertise in server configuration, maintenance, and troubleshooting</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)</li><li>Proficient in seamlessly conducting database upgrades, ensuring uninterrupted operations and system integrity.</li><li>Proficiency in configuring and utilizing monitoring and diagnostic tools to pinpoint and address database performance issues effectively</li><li>In-depth knowledge of the various configuration parameters tailored to the specific database management system</li>"}],"text":"Senior Database Administrator Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb","applyUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb/apply"},{"additionalPlain":"About the Team\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719198420770,"descriptionPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"28fe323b-ed5f-482b-b71d-ed60662bed8b","lists":[{"text":"What You Will Do","content":"<li>Develop automation scripts and tools for provisioning, deployment, monitoring, and backup/recovery of databases using infrastructure as code (IaC) principles</li><li>Implement robust monitoring and alerting systems for database performance metrics&nbsp;</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Maintain version-controlled configurations for database servers, ensuring consistency and repeatability across environments via IaC</li><li>Automate routine tasks such as database backups, schema migrations, and data archiving to improve operational efficiency</li><li>Develop database high availability and replication solutions to meet the requirements of critical applications.</li><li>Develop standardized operational procedures within the DBaaS framework to ensure the consistent provision of highly available solutions.</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li>"},{"text":"What You Will Need","content":"<li>5+ years Experience as a DevOps Engineer with a focus on database management</li><li>Hands-on experience with cloud platforms (AWS or GCP)</li><li>Proficiency in scripting languages such as Go, Shell, and Ruby for automation tasks</li><li>Experience with infrastructure as code tools (e.g., Terraform, CloudFormation) for provisioning and managing database resources</li><li>In-depth knowledge of database systems such as MySQL, PostgreSQL, MongoDB, etc., including configuration, optimization, and troubleshooting</li><li>Strong understanding of CI/CD practices and tools</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)&nbsp;</li><li>Experience in configuration management tools (eg: ansible) for database patching and maintenance automation</li>"}],"text":"Senior DevOps Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b","applyUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1706508052225,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","id":"da8d4a37-f5a4-4436-8743-58c787781285","lists":[{"text":"What You Will Do","content":"<li>Take ownership of one of OKR related to demand and growth that leads to revenue and profitability from one of Gojek product’ business; defines the strategy and roadmap for the team to achieve it by combining multiple initiatives (e.g., content/communication, vouchers/promotion, product changes)</li><li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Build predictive model or clustering model to allocate the promo allocation efficiently</li><li>Run multiple experiments to validate hypothesis in fast pace iteration cycle</li><li>Drives the team for prioritization, strategy, and focus on solutions to solve user problems</li><li>Introduce beneficial business changes through well-written strategy documents and validate the strategy and hypotheses through robust experimentation and statistical approach</li><li>Optimize and automate solutions by leveraging Data Sciences resources</li><li>Perform feedback loop and retroactive analysis of the team performance and operation to evaluate and improve their impact on Gojek’'s North Star Metrics</li><li>Proactively review the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Present findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis.</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 5 years of working experience with a minimum of 1-2 year of leadership experience</li><li>Proficiency in data analysis tools and programming languages such as Python, R, SQL, and data visualization tools like Tableau or Power BI. Strong analytical skills to interpret complex data sets and extract actionable insights</li><li>High proficiency in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficiency in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Understanding of business operations, strategies, and objectives. The Consumer Analytics Lead should be able to connect analytical insights to business goals and contribute to overall decision-making</li><li>Data Management: Familiarity with data collection, storage, and management best practices</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Experience in a SaaS, Marketplace, Food Delivery, or other technology company is a plus</li>"}],"text":"Senior Growth Manager - Food & Ads","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285","applyUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285/apply"},{"additionalPlain":"About The Team\n\nThe mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.\n\nThe Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.\n\nIn addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.</div><div><br></div><div>The Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.</div><div><br></div><div>In addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.</div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Jakarta","team":"-","allLocations":["Jakarta","Bengaluru"]},"createdAt":1721729849780,"descriptionPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","description":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","id":"e6583aa0-7097-4e6f-9f91-7f24d5441156","lists":[{"text":"What You Will Do","content":"<li>Develop and communicate a clear product vision and roadmap for data science/GenAI platforms/products, and Streaming/Batching Pipeline products.</li><li>Lead the end-to-end product development lifecycle from ideation through launch and iteration, aligning product strategies with business objectives and stakeholder needs.</li><li>Collaborate closely with cross-functional teams, including engineering, data science, analytics, and operations, to deliver high-quality products.</li><li>Prioritize features and improvements based on data analysis, user feedback, and business impact.</li><li>Utilize data-driven insights to inform product decisions and measure the impact of product features.</li><li>Implement and track key performance indicators (KPIs) to ensure product success and drive continuous improvement.</li><li>Foster a culture of experimentation and iteration to optimize product performance and user satisfaction.</li><li>Communicate product updates, progress, and challenges effectively to stakeholders at all levels of the organization.</li>"},{"text":"What You Will Need","content":"<li>5+ years of product management experience, specializing for at least 3 years in data science platforms, data pipelines, or related products.</li><li>Proven track record of successfully managing complex technical products in fast-paced environments.</li><li>Strong understanding of data science, and data engineering principles.</li><li>Experience with streaming and batching data processing technologies such as Apache Kafka, Spark, Flink, etc will be a big plus.</li><li>Strong analytical and problem-solving skills, leveraging a data-driven approach to decision-making.</li><li>Excellent verbal and written communication skills.</li><li>Demonstrated leadership abilities, capable of inspiring and motivating cross-functional teams.</li>"}],"text":"Senior Product Manager, Data Science Platform and Data Products","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156","applyUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156/apply"},{"additionalPlain":"About The Team\n\nOur Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. </div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1717126992883,"descriptionPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","id":"50c8a826-2076-40a3-a829-b96b29c9647f","lists":[{"text":"What You Will Do","content":"<li>Conduct research to understand merchants needs and behavior and analyze product performance data to identify opportunities&nbsp;</li><li>Developing and executing a data-driven marketing strategy that aligns with the overall business objectives</li><li>Create product positioning and messaging to differentiate our products from competitors</li><li>Creating and managing marketing campaigns across various channels, including search, social media, and email marketing by working together with both internal and external stakeholders to deliver the plan</li><li>Developing and managing referral or other marketing programs to drive merchant acquisition</li><li>Identify, develop, implement, and refine consumer-focused lifecycle &amp; retention marketing strategies</li><li>Continuously monitor and analyze data to create campaign or marketing reports</li><li>Running A/B tests and analyzing results to optimize conversion rates and user acquisition.</li>"},{"text":"What You Will Need","content":"<li>3+ years working experience in Tech, Bank, Consulting or Marketing Agencies</li><li>2+ years experience in marketing or growth roles</li><li>Customer obsession and passionate in marketing</li><li>Strong analytical skills, data-driven and delighted with statistical analysis and figures</li><li>Strong communication skills, collaborative spirit, delighted to work with other stakeholders (BI/Data, Business, Product, Leadership)</li><li>Strong business sense and problem-solving skills</li>"}],"text":"Senior Product Marketing Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f","applyUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1722243132222,"descriptionPlain":"About The Role\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","id":"afd9e752-82f0-4b4f-a4ef-5d86dcce1063","lists":[{"text":"What You Will Do","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed</li><li>Resolve account issues and complaints</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms</li>"},{"text":"What This Role Needs","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area</li><li>At least 6 years of experience in business management, sales, or project management is mandatory. Prior experience in e-commerce and managing key accounts will be a plus point</li><li>Fluency in both Bahasa and English is required</li><li>Able to multitask, prioritize, and manage time efficiently</li><li>Ability to negotiate, persuade and influence others</li><li>Excellent interpersonal, communication, presentation and analytical skills</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners</li>"}],"text":"Senior Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","descriptionBodyPlain":"About The Role\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063","applyUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063/apply"},{"additionalPlain":"About the Team\n\nThe Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721742951306,"descriptionPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","description":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","id":"099498bc-c171-4505-97d7-3a432d302e14","lists":[{"text":"What You Will Do","content":"<li>Work and collaborate in Financial systems technical projects, especially in SAP ABAP and SAP BTP technologies</li><li>Collaborate with cross-functional and cross-department teams to analyze complex business requirements and design scalable solutions</li><li>Develop and maintain technical specifications, design documents, and other project artifacts</li><li>Provide technical support and guidance to development teams, ensuring high-quality code delivery</li><li>Participate in code reviews, ensuring adherence to coding standards and best practices</li><li>Contribute to the development of technical architecture and design patterns, providing recommendations for improving performance, scalability, and maintainability</li><li>Stay up-to-date with the latest SAP technologies and trends, and evaluate new technologies for potential adoption</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of experience in SAP application development, with a focus on SAP ABAP and SAP BTP technologies</li><li>Proven track record of delivering successful scalable technical projects</li><li>Strong technical skills in ABAP OO, SAP Gateway, CDS, AMDP</li><li>Strong technical skills in SAP BTP or SAP Integration Suite</li><li>Knowledge on modern integration, Unix environment, cloud platform technologies, and other stacks is a plus</li><li>Excellent communication and interpersonal skills, with the ability to work effectively in a team environment</li><li>Strong analytical and problem-solving skills, with the ability to think creatively and strategically</li>"}],"text":"Senior SAP Technical","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","descriptionBodyPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14","applyUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1706837996316,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"93b5e2e0-272f-4091-b7aa-fafc06ca67c4","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>4-6+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"Senior SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4","applyUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4/apply"},{"additionalPlain":"About our Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About our Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1700733541559,"descriptionPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","description":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","id":"472ae629-87cb-4f8c-bb69-eae35cf3751e","lists":[{"text":"What you’ll do","content":"<li>Develop and implement test automation tools and frameworks to ensure continuous testing of product features</li><li>Collaborate with product managers and engineers to understand requirements, document test cases, and define rollout/release strategies</li><li>Perform performance, load, and scalability testing for new features and product releases.</li><li>Debug and diagnose defects uncovered during testing to determine root causes. Log bugs accurately and communicate issues clearly to engineering teams</li><li>Monitor systems in production to identify and troubleshoot defects or anomalous behavior.</li><li>Stay up-to-date with new testing methodologies and tools</li><div><br></div><div><br></div>"},{"text":"What you’ll need","content":"<li>5+ years experience in a QA, SDET or DevX role, with expertise in test automation</li><li>Proficiency with one or more programming languages like Java, Go, Kotlin, Python</li><li>Experience testing complex distributed systems and microservices architectures</li><li>Understanding of SQL and NoSQL databases</li><li>Familiarity with technologies like Kafka, Docker, Kubernetes</li><li>Knowledge of financial systems, mobile apps, or SaaS products is a plus</li><li>Excellent verbal and written communication skills</li>"}],"text":"Senior SDET - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e","applyUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721811900324,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","id":"153e42ca-cf5b-4f43-b09e-58eabda1e5fa","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 4 years of experience in professional testing in App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin, experience with Flutter is a plus)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa","applyUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team :</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1722316158497,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role :</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</span></div>","id":"78d59624-b02e-4370-b23b-25677dfb1b20","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 5 years of experience in professional testing in Microservices/API/App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role :</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20","applyUrl":"https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1713506558950,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"076bd021-0157-42a4-89fd-51d9f236e490","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Payment Widget & Vendor Gateway","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490","applyUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490/apply"},{"additionalPlain":"About the Team\n\nThe Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.\n \nSome of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few. \n \nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.</div><div>&nbsp;</div><div>Some of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few.&nbsp;</div><div>&nbsp;</div><div>Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Marketplace","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1698659237440,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","id":"8d7ae844-168c-4e78-843a-94aceb7b1a66","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of relevant, hands-on experience with either  Golang, or Java</li><li>Ability to go in-depth across tech stacks used in the product</li><li>Experience working on large-scale, event-driven microservice architecture with active use of Kafka; ability to architect solutions based on this pattern</li><li>Familiarity with basic programming principles such as SOLID and TDD</li><li>Intermediate experience with Linux OS; ability to troubleshoot issues</li><li>A solid understanding of why we need to test code; experience implementing tests</li><li>Ability to understand/discuss design and performance trade-offs in complex systems</li>"}],"text":"Senior Software Engineer  - Marketplace","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66","applyUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66/apply"},{"additionalPlain":"About the Team\n\nWe are a team of developers, designers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers, designers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1722246725855,"descriptionPlain":"About the Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nThis role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more</span></div><div><br></div>","id":"d8170197-90ca-4f87-a48d-d1a3175538ce","lists":[{"text":"What You Will Do","content":"<li>Code, Design, prototype, perform reviews and consult in building highly scalable, reliable, and fault-tolerant systems</li><li>Containerisation and deployment of microservices on Kubernetes</li><li>Auto-scaling and monitoring performance of the streaming Infrastructure and applications by using Prometheus and Grafana or similar tools</li><li>Collaborate with the team to ensure that the service level objectives and agreements are achieved</li><li>Communicate and collaborate effectively with product, data science teams</li><li>Continue to stay abreast of the latest technologies in Event processing and Big Data space to inform/suggest new technologies and best practices to trial</li><li>Mentor and guide other engineers in the team</li>"},{"text":"What You Will Need","content":"<li>At least 4+ years of software engineering experience</li><li>Experience with containerization and DevOps, including Docker and Kubernetes</li><li>Experience with Kafka and stream processing like Flink or Spark Streaming</li><li>Must have hands-on experience using any of the cloud platforms (AWS, GCP, Azure), with thorough knowledge of cloud concepts</li><li>Demonstrated ability to take initiative and accountability for achieving results</li><li>Strong interpersonal and communication skills</li><li>Passion for learning new things and solving complex engineering blockers</li>"}],"text":"Senior Software Engineer - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">This role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nThis role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce","applyUrl":"https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711358848361,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"68f907a3-329f-411b-af2d-a66b38243919","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 5 years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>You have working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>You have Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, XGBoost, Keras</li>"}],"text":"Senior Software Engineer - Data Science Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919","applyUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919/apply"},{"additionalPlain":"About the Team\n\nWe are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.\n\nWe keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.\n\nThe Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.</span></div><div><br></div><div><span style=\"font-size: 16px\">We keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.</span></div><div><br></div><div><span style=\"font-size: 16px\">The Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721898140037,"descriptionPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","id":"57bb5e7f-9ea0-462f-ac36-5717b49d0380","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li><div><br></div>"},{"text":"What You Will Need","content":"<li>4-5 years of relevant experience. Hands-on in either Golang or Java</li><li>The ability to go into depth and breadth across tech stack used in the product vis-a-vis backend services, machine learning, data engineering, web development, data and analytics, infrastructure</li><li>Has worked on large scale event driven microservices architecture with an active use of Kafka and can architect solutions based on this pattern</li><li>Is familiar with basic programming principles such as SOLID and TDD</li><li>Has intermediate experience with Linux and is able to troubleshoot issues</li><li>Understands why we need to test code and has implemented tests</li><li>Able to understand/discuss design and performance trade offs in complex systems</li><div><br></div>"}],"text":"Senior Software Engineer - Go-food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px;\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380","applyUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718187134939,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"53c0b8a9-1a83-4c34-9a59-b5170ce54193","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Senior Software Engineer - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193","applyUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789054175,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","id":"fda395d6-457d-4a03-aaa1-33d513c3960b","lists":[{"text":"What You Will Do","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Software Engineer (Android) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b","applyUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b/apply"},{"additionalPlain":"About the Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713939159820,"descriptionPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","id":"d3b7122b-692b-4815-8aa9-f1d0259bccd5","lists":[{"text":"What Will You Do","content":"<li>Develop Java backend applications for the company, including web applications and server-side applications.</li><li>Be responsible for participating in the entire software development process, from requirement analysis to design, development, testing, and deployment, ensuring that our software products run efficiently and stably. The most significant thing is taking responsibility for results.</li><li>Architect and engineer robust, high-performance systems that can effortlessly handle scale, maintain reliability, ensure security, and gracefully handle faults.</li><li>Craft and refine our product vision into iterative Minimum Viable Products (MVPs), refining them as needed for scalability and adaptability.</li><li>Stay at the forefront of technology trends, continuously evaluating and incorporating new tools and methodologies to supercharge our development efforts.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","descriptionBodyPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5","applyUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789283382,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","id":"769b7391-e6fd-4923-9a92-e060f14e451d","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis, and MySQL.</li><li>Contributed to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization. Therefore, in addition to technical prowess, a keen understanding of financial business and self-motivation are emphasized.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>3+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Highly preferable experience in Golang</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d","applyUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d/apply"},{"additionalPlain":"About the team \n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the team </b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713777541586,"descriptionPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","description":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","id":"ad7a1160-4d07-4f4a-a2d3-c362afac18ac","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis and MySQL</li><li>Contribute to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred</li><li>Familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis</li><li>Familiar with Linux operating systems, understand database principles, and proficient in using databases like MySQL and Oracle</li><li>Good coding style and code specifications, and be able to independently complete project development</li><li>Good communication skills and teamwork spirit, and be able to collaborate effectively with other developers</li><li>knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Backend) - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","descriptionBodyPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac","applyUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710229562529,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"10dbc666-80f8-4250-85ee-59fa92d056aa","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Golang.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Good understanding of the full life cycle of the data warehouses.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Data Warehouse)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa","applyUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788927036,"descriptionPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","id":"bcd00ee0-2fb3-43c1-8401-ef184283ccc8","lists":[{"text":"What You Will Do","content":"<li>Design, build, deliver, and own development lifecycle from inception to production</li><li>Collaborate with the UI/UX team to write, design, and build high-quality front-end code and reusable components</li><li>Participate in and be responsible for front-end architecture design, and program decision-making, as well as creating technical standards and specifications;</li><li>Try improving engineering standards, tooling, and processes after understanding the business and team’s needs</li><li>Lead others through example, mentorship, teaching, code reviews, advocating, and maintaining suitable engineering standards for the team</li><li>Maintain close relations cross-department and gain from their expertise/share your learnings with them</li>"},{"text":"What You Will Need","content":"<li>3-4+ years of proven track record in JavaScript/ Typescript, CSS , HTML, DOM, network protocol, and other front-end related technologies, have in-depth experience in at least one of the mainstream front-end frameworks (React/ Vue /Angular, etc.) and understand the implementation principle</li><li>Good product awareness, service awareness, and sense of responsibility, can be independent and attention to user experience</li><li>Problem-Solving: Exceptional problem-solving skills with a track record of analyzing complex technical challenges and providing innovative solutions.</li><li>Communication: Excellent communication skills, with the ability to effectively convey technical concepts to both technical and non-technical stakeholders.</li><li>Leadership: Strong leadership experience, including mentorship, and technical guidance</li>"}],"text":"Senior Software Engineer (Front End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8","applyUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789167169,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","id":"e6c36118-5d4e-444b-922c-68e03c2ab82e","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Flutter and iOS.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3+ years of experience with iOS development and Flutter combined</li><li>Proficient in Swift programming, Cocoa, Xcode, the iOS SDK, Dart, and Flutter</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar).</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e","applyUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1708271973710,"descriptionPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","id":"389c0346-14e0-40e5-85c3-48d830db73b4","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Swift.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3 to 6+ years of experience with iOS development</li><li>Proficient in Swift programming, Cocoa, Xcode, and the iOS SDK</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar)</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Money Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","descriptionBodyPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4","applyUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899734506,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"449dd201-2d4d-47a0-9cd4-c7ddec91c88e","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data streaming products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Java.</li><li>Good understanding of real-time data streaming technologies like Flink, spark etc.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Real-Time Data Streaming)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e","applyUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1716821917651,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"8afd4278-a5a8-43f2-8718-2986433f2ddb","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.&nbsp;&nbsp;</li>"}],"text":"Senior Technical Program Manager - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb","applyUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717153383212,"descriptionPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","description":"<div><span style=\"font-size: 9pt\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","id":"3377f50a-d56f-42e0-acc5-b69d405a37a9","lists":[{"text":"What You Will Do","content":"<li>Identify and pursue strategic partnership opportunities that align with company goals - B2B in financial and non financial sectors</li><li>Negotiate terms and agreements with partners to drive mutual commercial successDevelop and maintain strong relationships with external partners to foster long-term collaboration</li><li>Collaborate with partners to create joint business plans aimed at achieving quarterly (QoQ) and yearly (YoY) growth targets</li><li>Monitor and analyze partnership performance, providing insights and recommendations for improvement</li><li>Work closely with internal teams, including sales, marketing, product, and finance, to ensure partnership initiatives are aligned with company objectives and obtain their successful buy in to projects and programs</li><li>Facilitate effective communication and collaboration across departments to gain buy-in for partnership strategies</li><li>Act as a liaison between partners and internal stakeholders to address any issues and optimize partnership outcomes</li><li>Be the first hand to handle issues related to the partnership and escalate the issue to the right parties (internal and external) to be solved</li><div><br></div>"},{"text":"What You Will Need ","content":"<li>Minimum Bachelor’s degree</li><li>Minimum 5 years of professional experience in partnership development or business development in companies such as start-ups, technology companies, management consulting, banking, or Fortune 500 companies</li><li>Data Analysis: Strong ability to crunch data and perform detailed data analysis. This includes interpreting complex datasets to derive actionable insights and support decision-making.</li><li>P&amp;L Understanding: Good understanding of Profit and Loss statements, with the ability to analyze financial performance and identify <a href=\"http://trends.Business\" class=\"postings-link\">trends.</a></li><li><a href=\"http://trends.Business\" class=\"postings-link\">Business</a> Acumen: Solid business acumen, enabling the development, management, and execution of business agreements and contracts. This involves a deep comprehension of business operations and strategic <a href=\"http://planning.Critical\" class=\"postings-link\">planning.</a></li><li><a href=\"http://planning.Critical\" class=\"postings-link\">Critical</a> Thinking and Problem Solving: Draws sound conclusions based upon a mixture of analysis and experience. Able to identify breakthrough solutions during tough negotiations or large-scale implementations with strategic <a href=\"http://partners.Communications\" class=\"postings-link\">partners.</a></li><li><a href=\"http://partners.Communications\" class=\"postings-link\">Communications</a> Skills: Promotes an environment of open communication. Convinces and engages others by using compelling arguments. Able to rigorously manage a portfolio of projects with strategic partners, unblock issues &amp; risks and manage expectations to ensure they are completed within target timelines and stakeholder <a href=\"http://expectations.Stakeholder\" class=\"postings-link\">expectations.</a></li><li><a href=\"http://expectations.Stakeholder\" class=\"postings-link\">Stakeholder</a> Management: Ability to develop strong, long lasting relationships with both internal and external stakeholders at all levels. Persuades and influences effectively by building support for ideas and initiatives through the effective presentation of facts and evidence. Identifies and anticipates that the partner and stakeholder needs to gain their commitment. Owns the end-to-end relationship with equivalent team and functional leads both internally and <a href=\"http://externally.B2B\" class=\"postings-link\">externally.</a></li><li><a href=\"http://externally.B2B\" class=\"postings-link\">B2B</a> Negotiation Skills: A fair, unbiased mediator and uses diplomacy and tact to diffuse tense situations comfortably</li><li>Resiliency : Demonstrates resilience &amp; composure, even in difficult or adverse circumstances. Makes and carries through unpopular or difficult decisions that are in the best interest of the team. Is able to resist the pressure to make quick decisions where due consideration is <a href=\"http://required.Abilities\" class=\"postings-link\">required.</a></li><li><a href=\"http://required.Abilities\" class=\"postings-link\">Abilities</a> to navigate and execute in a highly ambiguous environmentLocal candidates is a must</li><div><br></div>"}],"text":"Senior/Partnership Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt;\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","descriptionBodyPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","hostedUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9","applyUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9/apply"},{"additionalPlain":"About the Team\n\nAs a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.\n\nOur team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>As a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.</div><div><br></div><div>Our team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705293453270,"descriptionPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","id":"9b2d9240-3315-4b28-a7d6-73e2a097c8d7","lists":[{"text":"What You Will Do","content":"<li>Proactively monitor and troubleshoot system performance, identifying and addressing potential issues.</li><li>Collaborate with development teams to design and implement scalable and resilient system architectures.</li><li>Develop and maintain automation tools to streamline processes and enhance overall system efficiency.</li><li>Participate in incident response activities, conducting root cause analysis</li><li>Contribute to the ongoing improvement of reliability, scalability, and performance of critical infrastructure.</li><li>Work closely with cross-functional teams to align SRE efforts with broader organizational goals.</li>"},{"text":"What You Will Need","content":"<li>Solid understanding of cloud platforms such as GCP, and expertise in deploying and managing services within these environments.</li><li>In-depth knowledge of containerization technologies like Docker and orchestration tools such as Kubernetes</li><li>Proficiency in programming languages like Python, Go, or Java, with a strong software engineering foundation</li><li>Able to manage small teams and also can work as an individual contributor</li><li>Familiarity with Linux System, monitoring and logging tools to ensure comprehensive system visibility such as Prometheus, Grafana, and ELK stack</li><li>Proven track record of implementing and maintaining automation for deployment, scaling, and system orchestration.</li>"}],"text":"Site Reliability Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","descriptionBodyPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7","applyUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7/apply"},{"additionalPlain":"About the Team \n\nOur Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.\n\nHaving a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.  \n\nWe are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Our Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.</div><div><br></div><div>Having a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.&nbsp;&nbsp;</div><div><br></div><div>We are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717664713208,"descriptionPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","id":"f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","lists":[{"text":"What Will You Do ","content":"<li>Be the person in charge to create social media campaign and content; from observing trends and references, brainstorming, planning to execution (including schedule and post)</li><li>Develop social media campaigns strategies collaborate with other stakeholders&nbsp;&nbsp;</li><li>Create KOL strategy collaborate with stakeholders and third parties</li><li>Utilizing social media tools to analyze social media campaign, content, and KOL to gather insight and action plan</li><li>Collaborate with brand marketing to deliver/support marketing needs</li>"},{"text":"What Will You Need","content":"<li>At least 3-5 years related work experience from an advertising agency or start-up</li><li>Strong writing, editing, and proof-reading skills</li><li>Ability to communicate ideas clearly; a strong analytical, data-driven mindset</li><li>Broad knowledge of social media landscape, platforms, and technologies</li><li>Have interest in digital platforms, particularly in social media, and a willingness to learn more about this digital space</li><li>Strong team player with a proactive attitude and a creative/innovative mind to collaborate with multiple stakeholders</li><li>Strong analytical abilities to read, interpret, and utilize data, and to come up with actionable points for optimization and/or experimentation</li><li>Robust and detail-oriented to handle multiple works</li>"}],"text":"Social Media Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","descriptionBodyPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","applyUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898426994,"descriptionPlain":"\n","description":"<div><br></div>","id":"180b3e9e-cfb9-471d-8c30-410aef031535","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features &amp; participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team &amp; be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment &amp; work closely on the production environment, maintaining product’s&nbsp; uptime, reliability and SLOs</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby Proficient in OOP, SQL, Design Patterns</li><li>Experience with data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer  - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535","applyUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535/apply"},{"additionalPlain":"About the Team \n\nMxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).\n\nCore areas that we focus on - \nDeveloper Experience and Tooling: We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.\n\nFoundation and Building Blocks: This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!\n\nApp Excellence and Insights Tooling: The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">MxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).</span></div><div><br></div><div><b style=\"font-size: 16px\">Core areas that we focus on - </b></div><div><b style=\"font-size: 16px\">Developer Experience and Tooling: </b><span style=\"font-size: 16px\">We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.</span></div><div><br></div><div><b style=\"font-size: 16px\">Foundation and Building Blocks:</b><span style=\"font-size: 16px\"> This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!</span></div><div><br></div><div><b style=\"font-size: 16px\">App Excellence and Insights Tooling: </b><span style=\"font-size: 16px\">The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697010103248,"descriptionPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","id":"3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","lists":[{"text":"What You Will Do ","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need ","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Software Engineer - Android","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px;\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","applyUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897603986,"descriptionPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"96562e50-0bf7-4a14-a910-4ef63f16d451","lists":[{"text":"What You Will Do","content":"<li>Build large-scale and high-performance services to develop simple, easy-to-use products for our unique end customers</li><li>Design and develop a highly maintainable and reliable Android app</li><li>Write clean and tested code, mostly in Kotlin for Android native environment</li><li>Coordinate with other teams (Product Management, UX/Design, Backend Engineering, and Quality Engineering teams) on building and managing the Android app</li><li>Implement tech excellence in the Android development environment</li><li>Help in a constant exploration of new technology and tools</li><li>Deliver solutions that bring a positive impact to low-income communities through up-to-date software technologies</li><li>Going forward, you will have to work on flutter application as well</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience in software engineering</li><li>Strong knowledge of Kotlin, Android tools and framework, and Android Studio</li><li>Good skill in unit tests. Plus points for UI tests</li><li>Experience in using app vitals and performance monitoring systems</li><li>Experience building an end-to-end system, preferably for a large user base</li><li>Strong attention to detail, particularly on software engineering fundamentals, testing methodologies, and quality</li><li>Familiarity with Android design patterns</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - Android (Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451","applyUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451/apply"},{"additionalPlain":"About the Team\n\nThe Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).\n\nOne of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.\n\nOff hours, you’d probably find us hang out, dinner together or playing games\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).</div><div><br></div><div>One of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.</div><div><br></div><div>Off hours, you’d probably find us hang out, dinner together or playing games</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697610584742,"descriptionPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","id":"cd554abc-dc06-4177-be50-ccbc638fd6d9","lists":[{"text":"What You Will Do","content":"<li>Work closely with team lead to deliver product features that enable efficient handling of queries for our internal users (customer service agents) and complaints raised by external users (customer, driver, and merchant)</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems</li><li>Write code that’s clear, concise, performant, tested and easily understood by others</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Writing technical documents and providing technical training for end users if necessary</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2-3+ years of hands-on experience in designing, developing, testing, and deploying applications on Go-Lang, Clojure, Java, Ruby, or OOPL large-scale applications</li><li>In-depth experience&nbsp;of at least one programming language and framework, deep understanding of SQL databases, Linux, Kafka, Redis, and RabbitMQ</li><li>Proficient in OOP, SQL, Design Patterns Data modeling experience in Relational databases</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate risks</li>"}],"text":"Software Engineer - Customer Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9","applyUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><span style=\"font-size: 16px\"><b>About the Team</b></span></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897318094,"descriptionPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><span style=\"font-size: 16px\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"4439eb62-6f08-444b-946d-1dff07d7d0d3","lists":[{"text":"What You Will Do","content":"<li>Working on mobile applications iOS and going forward you will work on flutter application</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, communicate project/development status to internal and external teams in a timely fashion</li><li>Participating in the design review process, seeking and providing constructive criticism</li><li>Improving code structure and architecture in service of testability and maintainability</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentations of how their design and architecture evolves over time</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>2-4 years of experience with iOS development</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in Swift programming, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Understanding of iOS Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third party libraries for networking, async, image loading etc</li><li>Good analytical and problem solving skills</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - iOS ( Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3","applyUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3/apply"},{"additionalPlain":"About the Team\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716980506841,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","id":"930cfb6b-99e3-4334-bc10-3fac18f8eff0","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Helping out in onboarding process by sharing contexts and pairing with new member of the team</li><li>Start mentoring or guiding SE1</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years relevant software development experience through internship stint and/or college projects</li><li>Proficient in Kotlin programming, Java and the Android APIs. </li><li>Strong knowledge in Android Apps architecture and implementationAbility to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular libraries for networking, async, image loading etc.</li><li>Well-versed with Agile methodologies, TDD and Test Engineering and Automation.</li>"}],"text":"Software Engineer (Android) - Gofood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0","applyUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0/apply"},{"additionalPlain":"About the Team\n\nMerchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nOur team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Merchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>Our team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Merchant Lending","allLocations":["Jakarta"]},"createdAt":1721735169268,"descriptionPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","id":"dab778da-b4eb-4e7e-bc8e-997af7210d52","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain user-facing features, translating designs and requirements into well-designed, testable and efficient code</li><li>Collaborate with other team members and stakeholders to deliver high-quality software solutions</li><li>Troubleshooting and debugging to optimize performance.</li><li>Be proactive, ask questions, and be an active member of the team striving towards improving the merchant experience&nbsp;</li><li>Learn new technologies to keep yourself updated and brainstorm with the managers about using the new technologies in day-to-day problem-solving</li>"},{"text":"What You Will Need","content":"<li>Degree/Diploma in Computer Science, Engineering, or related field.</li><li>2+ years of experience in developing using Java</li><li>Understand programming practices such as separation of concerns, unit testing, and writing self-documenting code</li><li>Familiarity with mainstream frameworks like Spring, Spring Boot, and Linux operating systems, understanding of database principles, and proficiency in using databases like MySQL or PostgreSQL.</li><li>Familiarity with front-end related technologies and concepts such as Javascript/Typescript, CSS, HTML, DOM, network protocol, and mainstream front-end frameworks</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (Back End) - Merchant Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52","applyUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713521223842,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"331177df-4294-4bc1-93a4-6459ff18ef97","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97","applyUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899384459,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"c0e92e19-ce60-4cfc-a58b-553f17452483","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483","applyUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483/apply"},{"additionalPlain":"About the Team\n\nConsumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1714016329286,"descriptionPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","id":"88358de8-e37b-4bd6-9afe-359eea3128b9","lists":[{"text":"What You Will Do","content":"<li>Own feature development from end-to-end, constantly pair with junior engineers, and improve them.</li><li>Write code that's clear, concise, performant, tested, and easy to understand by other teams and engineers.</li><li>Contribute to the design and development of highly scalable, available, reliable, secure, and fault-tolerant services.</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices.</li><li>Deep dive and debug production issues across services and levels of the stack when needed.</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently.</li>"},{"text":"What You Will Need","content":"<li>Passion for software development</li><li>At least 3 years of relevant software development experience with consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Ability to learn or use Java, Kotlin, and JS, proficiency in at least one of them</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, database consistency and transactionality, asynchronous programming, fault tolerance and monitoring, performance, feature flags, and backward compatibility&nbsp;</li><li>Understanding of a mobile application’s interaction with the back-end and other systems</li><li>Deep understanding of relational databases; ability to design performant, easy-to-understand architectures, and know-how for applying changes with no downtime to production systems</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, AWS, GCP</li>"}],"text":"Software Engineer (Full Stack) - BNPL","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","descriptionBodyPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9","applyUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9/apply"},{"additionalPlain":" About the team\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div>&nbsp;<span style=\"font-size: 16px\">About the team</span></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899689491,"descriptionPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","id":"89a62415-b145-4593-ac20-b82ec0ccfacb","lists":[{"text":"What You Will Do","content":"<li>Solve technical problems and build the next generation of products for our consumers</li><li>Spike new technologies and find a viable way to improve customers experience</li><li>Improve the testability and maintainability of the code</li><li>Build reusable iOS software components for interfacing with multiple applications</li><li>Improve and stabilize IOS sdks used by number of internal and external clients</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>At Least 2 years of full-time iOS engineering experience</li><li>Experience developing, maintaining, and innovating large scale, consumer mobile application</li><li>Predictability and balance of product delivery speed and quality</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in <b>Swift programming</b>, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Working experience with popular libraries for networking, async, image loading, etc</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><li>Experience and knowledge of writing testable and high-quality code</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (iOS) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","descriptionBodyPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb","applyUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb/apply"},{"additionalPlain":"About the Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</div><div><br></div><div>Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</div><div><br></div><div>As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).</div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1719909295384,"descriptionPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","description":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","id":"1a190954-9482-4953-a750-f2ae33a50003","lists":[{"text":"What You Will Do","content":"<li>Develop and Test: Write, test, and maintain software across our platforms, ensuring robustness and scalability.</li><li>Collaborate: Work closely with senior engineers and cross-functional teams including Backend, Frontend, Mobile, and QA to design and execute solutions.</li><li>Learn and Grow: Receive mentorship from senior engineers, enhancing your understanding of software development processes and best practices.</li><li>Contribute: Play a key role in the development and optimization of new features and systems within Midtrans.</li>"},{"text":"What You Will Need","content":"<li>Currently enrolled in or recently graduated with a degree in Computer Science, Software Engineering, or a related field.</li><li>Strong foundational knowledge in at least one programming language (Java, Python, JavaScript, etc.).</li><li>Understanding of basic software development concepts and methodologies.</li><li>Familiarity with version control systems, preferably Git.</li><li>Problem-Solving: Ability to think critically and solve complex problems.</li><li>Communication: Excellent verbal and written communication skills.</li><li>Teamwork: Eagerness to work within a team-oriented environment.</li><li>Adaptability: Openness to learning new technologies and methodologies.</li>"}],"text":"Software Engineer Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","descriptionBodyPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003","applyUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003/apply"},{"additionalPlain":"About the Team\n\nThe Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">The Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721305380078,"descriptionPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","id":"75c0d634-b28a-4f10-8f5a-efacb32b6444","lists":[{"text":"What You Will Do","content":"<li>Collaborate with product engineers to unify and optimize build standards across Android apps</li><li>Enhance build performance and streamline development processes</li><li>Identify and resolve bottlenecks in the current build system.Forecast and future-proof Android platform engineering services</li><li>Implement best engineering practices and ensure adherence across product groups</li><li>Conduct thorough code reviews and provide constructive feedback</li><li>Mentor junior engineers and support their professional growth</li><li>Participate in architectural design reviews and contribute to technical decision-making</li>"},{"text":"What You Will Need","content":"<li>5+ years of mobile engineering experience with Android as primary expertise</li><li>Proficiency in writing clear, concise, and maintainable code</li><li>Experience with collaborating on projects involving multiple teams</li><li>Strong understanding of mobile app architecture, testing, and performance optimization</li><li>Passion for building scalable and reusable systems</li><li>Ability to make informed decisions in architectural design reviews</li><li>Experience with build systems and CI/CD pipelines</li><li>Familiarity with Flutter or a willingness to learn it</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Sr. Software Engineer (Android) - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444","applyUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444/apply"},{"additionalPlain":"About the Team\n\nOur Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nTransport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)  using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Transport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)&nbsp; using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717676182978,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","id":"22ac4805-bcbe-4698-9e51-cb25754ac244","lists":[{"text":"What You Will Do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Actively mentor SE/ASEs&nbsp; in the team</li><li>Translate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environments</li><li>Improve engineering standards, tooling and processes</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applications</li><li>Have expertise in at least one of Go or Java</li><li>In-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etc</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"Sr. Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244","applyUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks\n\nYou get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks</span></div><div><br></div><div><span style=\"font-size: 16px\">You get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Jakarta"]},"createdAt":1713436041495,"descriptionPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","id":"e2bbb29c-85ef-4db2-9ea7-93af9101b634","lists":[{"text":"What You Will Do","content":"<li>Automate mechanism to make sure app performance adheres to the standards set internally</li><li>Building tools that would alleviate mobile engineer's development experience and productivity&nbsp;</li><li>Build dashboard and alerting system around mobile app performance (using tools like Firebase, Instabug, etc)</li><li>Foster a development culture that focuses on the quality of delivery</li><li>Creating and maintaining SDKs like networking, logging, etc. These sdk’s are responsible for providing common solutions to products across all iOS mobile teams</li><li>Continuously discover, evaluate, and implement new technologies to maximize development efficiency</li><li>Create excellent, clear, and insightful documentation ex: guidelines, best practices, how-to, FAQs etc</li>"},{"text":"What You Will Need","content":"<li>Atleast 3+ years of mobile engineering experience with iOS as primary expertise</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Ability to can take (or pitch) technical decisions, own it and raise impediments early if needed</li><li>You are very well versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>You have a passion for building scalable and composable systems that would last long</li><li>You are a hands-on engineer with a focus on writing easy to read code than over-engineering</li><li>You are a great communicator who can express your ideas clearly and build consensus to push technical agendas</li>"}],"text":"Sr. Software Engineer (iOS) - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634","applyUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634/apply"},{"additionalPlain":"About the Team\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\n\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</span></div><div><br></div><div><span style=\"font-size: 16px\">We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717559195275,"descriptionPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","id":"8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","lists":[{"text":"What You Will Do","content":"<li>Help provide clarity and direction for marketing campaigns or initiatives</li><li>To become the bridge between the Creatives and the marketing, media, social, design, product and research team</li><li>Always bringing the consumer perspective into the creative process in Gojek by simply staying in touch with society and the trends that are changing it</li>"},{"text":"What You Will Need","content":"<li>You have at least 5 years of strategy experience in an agency or related environment</li><li>Ability to deliver a clear, insight-based strategic recommendation in the form of a written brief</li><li>Ability to support Creatives and Designers&nbsp; with relevant stimulus, routes, or advice</li><li>Ability to visualize simple customer journeys in clear &amp; compelling ways</li>"}],"text":"Strategic Planner - Creative Labs - #10088","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px;\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","descriptionBodyPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","applyUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713867338946,"description":"","descriptionPlain":"","id":"afb5bc40-aa4f-4837-a2d9-7d38eade2599","lists":[{"text":"What will you do","content":"<li>Assume ownership of key performance indicators (KPIs) driving revenue and profitability for Consumer Lending <a href=\"http://business.Develop\" class=\"postings-link\">business.</a></li><li><a href=\"http://business.Develop\" class=\"postings-link\">Develop</a> comprehensive strategies and roadmaps to achieve growth objectives through a combination of <a href=\"http://initiatives.Identify\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Identify\" class=\"postings-link\">Identify</a> growth opportunities within the consumer lending business by analyzing business data, transactional data, customer activity within platforms, and leveraging customer <a href=\"http://insights.Lead\" class=\"postings-link\">insights.</a></li><li><a href=\"http://insights.Lead\" class=\"postings-link\">Lead</a> the prioritization process, strategizing, and focusing on solutions aimed at addressing user needs and enhancing user <a href=\"http://experience.Validate\" class=\"postings-link\">experience.</a></li><li><a href=\"http://experience.Validate\" class=\"postings-link\">Validate</a> business strategies and hypotheses through rigorous experimentation and statistical <a href=\"http://methodologies.Present\" class=\"postings-link\">methodologies.</a></li><li><a href=\"http://methodologies.Present\" class=\"postings-link\">Present</a> findings and insights to senior management to inform strategic decision-making regarding feature prioritization and impact <a href=\"http://analysis.Cultivate\" class=\"postings-link\">analysis. </a></li><li><a href=\"http://analysis.Cultivate\" class=\"postings-link\">Cultivate</a> and manage partnerships with external stakeholders.</li>"},{"text":"What will you need","content":"<li>BS/MS in Business, Engineering, Computer Science, Math, Economics, Statistics, or <a href=\"http://equivalent.8-10\" class=\"postings-link\">equivalent.</a></li><li><a href=\"http://equivalent.8-10\" class=\"postings-link\">8-10</a> years of working experience with strong business <a href=\"http://acumen.End\" class=\"postings-link\">acumen.</a></li><li><a href=\"http://acumen.End\" class=\"postings-link\">End</a> to end problem-solving mindset that can work in increments and <a href=\"http://exponents.Strong\" class=\"postings-link\">exponents.</a></li><li><a href=\"http://exponents.Strong\" class=\"postings-link\">Strong</a> project management skills to manage complex projects, also can manage and prioritize multiple internal and external <a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">Proficiency</a> in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with good knowledge of SQL and experimentation processHustle is essential, moving quickly and executing to allow for continual iteration is a core competency of the teamExperience in a financial services and technology companies is preferred.</li>"}],"text":"Strategy Senior Manager, Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599","applyUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599/apply"},{"additionalPlain":"Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1709264557847,"descriptionPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","description":"<div><span style=\"font-size: 10pt\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","id":"eaab5bee-084d-4cdc-bd08-63230251009c","lists":[{"text":"What you will do","content":"<li>Develop and maintain supply related dashboards to monitor key metrics and compare achievements against targeted <a href=\"http://goals.Analyze\" class=\"postings-link\">goals.</a></li><li><a href=\"http://goals.Analyze\" class=\"postings-link\">Analyze</a> various data points, detect anomalies and spot trends to drive business and strategic decision-making on supply <a href=\"http://initiatives.Collaborate\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Collaborate\" class=\"postings-link\">Collaborate</a> with the BI, Data Science, Marketing, and Product Management teams to ensure alignment on data analysis, methodologies, insights, and recommendations and proactively escalate issues to relevant <a href=\"http://stakeholders.Analysis\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Analysis\" class=\"postings-link\">Analysis</a> on the competitive intelligence insights and <a href=\"http://findings.Be\" class=\"postings-link\">findings.</a></li><li><a href=\"http://findings.Be\" class=\"postings-link\">Be</a> the go-to person on anything related to the supply health metrics and analysis.</li><div><br></div>"},{"text":"What you will need","content":"<li>A BS/MS in Business, Engineering, Computer Science, Mathematics, Economics or equivalent experience</li><li>3+ years of experience within one or more of the following fields: Business Analytics, Strategy and Planning, Growth or relevant functions</li><li>Comfortable analyzing large amounts of raw data with an obsession to detail and accuracy of data</li><li>Able to uncover the story and relationship behind the numbers and communicate the insights to a wider audience</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Proficiency in multiple analytic, database, and visualization tools (e.g., Tableau, Looker Studio, etc.) along with strong knowledge of SQL</li><li>A scientific and hypothesis-driven thinking process with the ability to work in increments and exponents</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders </li><div><br></div>"}],"text":"Supply Strategy Data Analyst [Ads]","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","descriptionBodyPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c","applyUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c/apply"},{"additionalPlain":"About the team \n\nWe are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.\n\n","additional":"<div><b>About the team</b>&nbsp;</div><div><br></div><div>We are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - ESG","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721114762245,"descriptionPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","id":"1a303596-73f9-4d05-85f9-73cd361f03ef","lists":[{"text":"What you will do","content":"<li>Leading GoTo Group’s sustainability commitments and related workstreams, focusing on the company's environmental and socio-economic impact and financial inclusion of the ecosystem.</li><li>Overseeing Zero Barriers as a socio-economic pillar, focusing on the development of in-house financial products and services aimed at improving the economic well-being and sustainable livelihoods of GoTo’s drivers and merchant partners.</li><li>Implementing impact measurement frameworks to transparently communicate social and economic benefits resulting from company initiatives, reinforcing accountability.&nbsp;</li><li>Driving the implementation of comprehensive Diversity, Equity, and Inclusion (DEI) policies within GoTo, to foster a culture of equality and respect organization-wide.&nbsp;</li><li>Ensuring proactive compliance with relevant environmental, social, and governance (ESG) regulations, surpassing standards to uphold ethical business practices.</li>"},{"text":"What you will need","content":"<li>Extensive experience in ESG strategy, preferably within the tech industry.&nbsp;Strong understanding of global and local sustainability regulations and standards. (GRI, POJK, MSCI, S&amp;P, etc.)</li><li>Proven track record in leading sustainability initiatives and integrating them into business operations.</li><li>Excellent stakeholder management and communication skills.&nbsp;</li><li>Ability to analyze complex data and translate it into actionable strategies.&nbsp;Innovative thinking and problem-solving abilities.&nbsp;</li><li>Leadership skills with the ability to drive cultural change and motivate teams.&nbsp;</li><li>Proficiency in project management and sustainability reporting tools.</li>"}],"text":"Sustainability Senior Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef","applyUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720377852482,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically-oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.</li>"}],"text":"Technical Program Manager - Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","applyUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720689871979,"descriptionPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","id":"bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Support Head in establishing and strengthening relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors</li><li>Project Leadership: Support multiple projects in partnership with government institutions, focusing on Transport and Mobility technology.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances</li><li>Project Management: Support public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government</li><li>Established network among government stakeholder with a proven impact on policy decisions</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Transport and Mobility PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","descriptionBodyPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","applyUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705901801143,"descriptionPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","description":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","id":"17408b81-f5a0-4f15-afae-cc04ed7e43b6","lists":[{"text":"What You Will Do","content":"<li>Prepare Risk reporting and position reporting</li><li>Conduct assessments to define and analyze possible risks</li><li>Evaluate the gravity of each risk by considering its consequences</li><li>Design processes to eliminate or mitigate potential risks</li><li>Evaluate existing policies and procedures to find weaknesses</li><li>Prepare reports and present recommendations</li><li>Ensure risk exposures of the company is within stipulated limits</li><li>Work closely with other business stakeholders</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years&nbsp;</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal and external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL will be an advantage</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Underwriting and Credit Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","descriptionBodyPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6","applyUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6/apply"},{"additionalPlain":"About The Team\nMerchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Merchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721636128423,"descriptionPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","id":"a007af4b-690d-4487-874d-f04ce3f62ce0","lists":[{"text":"What You Will Do","content":"<li>Maintain relationship with BPO vendor and regularly evaluate their productivity&nbsp;</li><li>Become a COE of merchant engagement framework for region team</li><li>Assisting SM Merchant Engagement in managing milestones, timeline, as well the stakeholders engagement related to the managed projects.</li><li>Develop and updating Key Insights and Analysis related to Unmanaged merchants performances</li>"},{"text":"What This Role Needs","content":"<li>At least 2 years experience in field sales or telemarketing, especially with a proven track record of managing local / regional business in reputable companies</li><li>Experienced in managing large business partner such as distributor or outsourcing vendor</li><li>Have experience in basic to intermediate data analytics skills</li><li>Having ability to turn insight into actionable plan</li><li>Strong business acumen with proven track record in stakeholder management</li>"}],"text":"Unmanaged Merchant Engagement Senior Associate - #10326","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","descriptionBodyPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0","applyUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119556899,"descriptionPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","id":"147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","lists":[{"text":"What you will do","content":"<li>Own the GoMart Growth Strategy and Promotion budgetTake charge of monthly budgeting and weekly execution with an emphasis on growth while maintaining profitability</li><li>Lead initiatives, strategies, and implementation, with a primary focus on the customer lifecycle funnel targeting the acquisition of new and churned users while growing retention of existing customers through a compelling offer.</li><li>Experiment with a combination of multiple initiatives (e.g. vouchers/promotion, product or pricing changes) to validate initiatives through statistical analysis</li><li>Use data across customer, driver, and merchant activity from multiple products to hypothesize potential solutions and test them in practice&nbsp;</li><li>Collaborate with Merchandising, Marketing, Product, and Operations teams in the development and implementation of initiatives and strategies</li><li>Prepare routine reports and present findings to leadership as the basis of rationale and recommendations for strategic decision-making</li>"},{"text":"What you will need","content":"<li>At least 5 years of experience in strategy or growth role at a tech company, e-commerce, or management consulting background</li><li>Strong proficiency in Microsoft Excel; Understanding of SQL and other statistical tools is a must.</li><li>Strong business acumen, an end-to-end problem-solving mindset with the ability to work in increments and exponents and balance attention to detail with swift execution</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"User Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","applyUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663/apply"}]
+  recorded_at: Tue, 30 Jul 2024 16:28:24 GMT
 - request:
     method: get
     uri: https://jobs.lever.co/GoToGroup
@@ -62,11 +62,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:44 GMT
+      - Tue, 30 Jul 2024 16:28:25 GMT
       Content-Type:
       - text/html; charset=utf-8
       Content-Length:
-      - '493822'
+      - '497174'
       Connection:
       - keep-alive
       Strict-Transport-Security:
@@ -76,14 +76,14 @@ http_interactions:
       X-Xss-Protection:
       - 1; mode=block
       Etag:
-      - W/"788fe-MFPhSoGT1QkImEA6O/6ZsJME4aU"
+      - W/"79616-uTPrEiNvBBML/V3WjdoJFASVwEM"
       X-Stream-Path:
       - djobs
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        <!DOCTYPE html><html><head prefix="og: http://ogp.me/ns#"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>GoTo Group</title><style>.template-btn-submit.hex-color {background: #00CC33;border-color: #00c230;color: white;}.template-btn-submit.hex-color:visited {color: white;}.template-btn-submit.hex-color:hover {background: #00c230;color: white;}.template-btn-submit.hex-color:active,.template-btn-submit.hex-color:focus {background: #008f24;color: white;}</style><meta name="twitter:card" value="summary"><meta name="twitter:title" content="GoTo Group"><meta name="twitter:description" content="Job openings at GoTo Group"><meta name="twitter:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733905611.png"><meta property="og:title" content="GoTo Group jobs" /><meta property="og:description" content="Job openings at GoTo Group" /><meta property="og:url" content="https://jobs.lever.co/GoToGroup" /><meta property="og:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733917014.png" /><meta property="og:image:height" content="630" /><meta property="og:image:width" content="1200" /><style>@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metaboldlf-webfont-2017.woff") format('woff');font-weight: 600;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormal-webfont-2017.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormalitaliclf-webfont-2017.woff") format('woff');font-weight: 400;font-style: italic;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metabolditaliclf-webfont-2017.woff") format('woff');font-weight: 600;font-style: italic;}@font-face {font-family: 'Meta-Caps';src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.eot");src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Avenir';src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.eot");src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.ttf") format('truetype');font-weight: normal;font-style: normal;}.caps-label,.classic-table th,h4,h6,th,.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.toggle-label,.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before,.cc-btn {font: 14px/1.4em 'Meta-Caps', sans-serif;text-transform: lowercase;letter-spacing: 1px;}.label,body,input,select,textarea,.btn-no-style,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {font: 400 14px/1.4em Meta, sans-serif;text-transform: none;letter-spacing: 0;}p.larger,.large-input,.large-input.dark,.message-banner {font: 400 16px/1.4em Meta, sans-serif;}h1,h2,h3,h5 {font: 600 16px/1.4em Meta, sans-serif;-webkit-font-smoothing: antialiased;}h1,h2,h3,h5 {color: #222326;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;top: 0;bottom: 0;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;right: 0;left: 0;}.hidden {display: none !important;}.fadein {-webkit-animation: lever-fadein 300ms ease-in;-moz-animation: lever-fadein 300ms ease-in;-o-animation: lever-fadein 300ms ease-in;-ms-animation: lever-fadein 300ms ease-in;animation: lever-fadein 300ms ease-in;opacity: 1;-ms-filter: none;filter: none;}.fadeout {-webkit-animation: lever-fadeout 300ms ease-in;-moz-animation: lever-fadeout 300ms ease-in;-o-animation: lever-fadeout 300ms ease-in;-ms-animation: lever-fadeout 300ms ease-in;animation: lever-fadeout 300ms ease-in;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.slidedown {-webkit-animation: lever-slidedown 300ms ease-in;-moz-animation: lever-slidedown 300ms ease-in;-o-animation: lever-slidedown 300ms ease-in;-ms-animation: lever-slidedown 300ms ease-in;animation: lever-slidedown 300ms ease-in;}.slideup {-webkit-animation: lever-slideup 300ms ease-out;-moz-animation: lever-slideup 300ms ease-out;-o-animation: lever-slideup 300ms ease-out;-ms-animation: lever-slideup 300ms ease-out;animation: lever-slideup 300ms ease-out;}.face-off {background-color: #f0f;}.face-off-border {border-color: #f0f !important;}.face-off-label {display: block;position: absolute;top: 24px;font-size: 24px;width: 100%;text-align: center;color: #fff;}.comma-separated:after {content: ", ";}.comma-separated:last-of-type:after {content: "";}.numbers,.dates,.count {font-family: 'Avenir';font-size: 0.857em;}.numbers,.dates {font-size: 0.92em;text-transform: uppercase;}.label {font-size: 12px;color: #969799;}.label.dark {color: #6a7c83;}.caps-label,.classic-table th {font-size: 12px;color: #969799;}.caps-label.dark,.classic-table th.dark {color: #6a7c83;}.vert-space-1 {margin-top: 5px;}.vert-space-2 {margin-top: 10px;}.vert-space-3 {margin-top: 15px;}.vert-space-4 {margin-top: 20px;}.vert-space-5 {margin-top: 25px;}.vert-space-6 {margin-top: 30px;}.vert-space-7 {margin-top: 35px;}.vert-space-8 {margin-top: 40px;}.vert-space-9 {margin-top: 45px;}.vert-space-10 {margin-top: 50px;}.vert-space-11 {margin-top: 55px;}.vert-space-12 {margin-top: 60px;}.full-width {width: 100%;}.left-align {text-align: left;}.right-align {text-align: right;}.centered {text-align: center;}.bulleted-list,.numbered-list {margin-left: 15px;}.bulleted-list li,.numbered-list li {margin-bottom: 8px;}.classic-table.fixed {table-layout: fixed;}.classic-table.no-padding td,.classic-table.no-padding th {padding: initial;}.classic-table.dark td,.classic-table.dark th {border-bottom: 1px solid #536266;}.classic-table.dark th {color: #6a7c83;}.classic-table td,.classic-table th {border-bottom: 1px solid #e3e4e6;padding: 10px 15px;vertical-align: top;}.classic-table td:first-of-type,.classic-table th:first-of-type {padding-left: 0;}.classic-table.no-bottom-border tr:last-child > td,.classic-table.no-bottom-border tr:last-child > th {border-bottom: none;}@-moz-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}* {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}body {background: #f9f9f9;color: #555659;}th {text-align: left;}body,dd,dl,dt,fieldset,form,h1,h2,h3,h4,h5,h6,li,menu,ol,p,td,th,ul,.toggle-label,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;}ul {margin: 0 auto;}table {border-collapse: collapse;border-spacing: 0;}fieldset,img {border: 0;}img.desaturate {-webkit-filter: grayscale(100%);}h1 {font-size: 36px;}h2,h5 {font-size: 24px;}h3 {font-size: 18px;}h5 {font-size: 16px;}h6,th {font-size: 12px;}a,a:visited {color: #579eee;text-decoration: none;}a:hover {color: #555659;cursor: pointer;}a:active {color: #0c92f3;}p>a {text-decoration: underline;color: inherit;}b {font-weight: 600;-webkit-font-smoothing: antialiased;}input,select,textarea {color: #555659;margin: 0;}input,select {height: 30px;}section {padding-bottom: 16px;}button {-webkit-appearance: button;-moz-appearance: button;appearance: button;cursor: pointer;}.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.cc-btn {position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 5px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;color: #555659;background: #fcfcfc;background: -webkit-linear-gradient(top, #fff, #f9f9f9);background: -moz-linear-gradient(top, #fff, #f9f9f9);background: -o-linear-gradient(top, #fff, #f9f9f9);background: -ms-linear-gradient(top, #fff, #f9f9f9);background: linear-gradient(to bottom, #fff, #f9f9f9);-webkit-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-moz-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-o-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-ms-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;}.btn:hover,.submit:hover,.btn-large:hover,.submit-large:hover,.btn-large-secondary:hover,.dark-button:hover,.cc-btn:hover,.btn-invisible:hover,.btn-no-style:hover {color: #1a1b1c;border-color: #969799;}.btn:active,.submit:active,.btn-large:active,.submit-large:active,.btn-large-secondary:active,.dark-button:active,.cc-btn:active {border-color: #555659;background: -webkit-linear-gradient(top, #f9f9f9, #fff);background: -moz-linear-gradient(top, #f9f9f9, #fff);background: -o-linear-gradient(top, #f9f9f9, #fff);background: -ms-linear-gradient(top, #f9f9f9, #fff);background: linear-gradient(to bottom, #f9f9f9, #fff);}.btn:active .icon >path,.submit:active .icon >path,.btn-large:active .icon >path,.submit-large:active .icon >path,.btn-large-secondary:active .icon >path,.dark-button:active .icon >path,.cc-btn:active .icon >path {fill: #555659;}.btn:focus,.submit:focus,.btn-large:focus,.submit-large:focus,.btn-large-secondary:focus,.dark-button:focus,.cc-btn:focus {outline: thin dotted;outline: 3px auto #0c92f3;outline-offset: -2px;}.btn.disabled,.submit.disabled,.btn-large.disabled,.submit-large.disabled,.btn-large-secondary.disabled,.dark-button.disabled,.cc-btn.disabled,.btn:disabled,.submit:disabled,.btn-large:disabled,.submit-large:disabled,.btn-large-secondary:disabled,.dark-button:disabled,.cc-btn:disabled,input.btn:disabled {cursor: default;pointer-events: none;-webkit-box-shadow: none;box-shadow: none;background: #e3e4e6;color: #555659;border-color: #dcdcdc;outline: none;}.btn.disabled.has-tip,.submit.disabled.has-tip,.btn-large.disabled.has-tip,.submit-large.disabled.has-tip,.btn-large-secondary.disabled.has-tip,.dark-button.disabled.has-tip,.cc-btn.disabled.has-tip,.btn:disabled.has-tip,.submit:disabled.has-tip,.btn-large:disabled.has-tip,.submit-large:disabled.has-tip,.btn-large-secondary:disabled.has-tip,.dark-button:disabled.has-tip,.cc-btn:disabled.has-tip,input.btn:disabled.has-tip {pointer-events: auto;}.btn.disabled:hover,.submit.disabled:hover,.btn-large.disabled:hover,.submit-large.disabled:hover,.btn-large-secondary.disabled:hover,.dark-button.disabled:hover,.cc-btn.disabled:hover,.btn:disabled:hover,.submit:disabled:hover,.btn-large:disabled:hover,.submit-large:disabled:hover,.btn-large-secondary:disabled:hover,.dark-button:disabled:hover,.cc-btn:disabled:hover,input.btn:disabled:hover,.btn.disabled:active,.submit.disabled:active,.btn-large.disabled:active,.submit-large.disabled:active,.btn-large-secondary.disabled:active,.dark-button.disabled:active,.cc-btn.disabled:active,.btn:disabled:active,.submit:disabled:active,.btn-large:disabled:active,.submit-large:disabled:active,.btn-large-secondary:disabled:active,.dark-button:disabled:active,.cc-btn:disabled:active,input.btn:disabled:active {color: #555659;background: #e3e4e6;border-color: #dcdcdc;}.btn.dropdown-button,.submit.dropdown-button,.btn-large.dropdown-button,.submit-large.dropdown-button,.btn-large-secondary.dropdown-button,.dark-button.dropdown-button,.cc-btn.dropdown-button {text-align: left;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;padding-right: 19px;}.btn.dropdown-button.full-width,.submit.dropdown-button.full-width,.btn-large.dropdown-button.full-width,.submit-large.dropdown-button.full-width,.btn-large-secondary.dropdown-button.full-width,.dark-button.dropdown-button.full-width,.cc-btn.dropdown-button.full-width {width: 100%;}.btn .icon >path,.submit .icon >path,.btn-large .icon >path,.submit-large .icon >path,.btn-large-secondary .icon >path,.dark-button .icon >path,.cc-btn .icon >path {fill: #555659;}.btn.has-icon,.submit.has-icon,.btn-large.has-icon,.submit-large.has-icon,.btn-large-secondary.has-icon,.dark-button.has-icon,.cc-btn.has-icon {padding-left: 41px;}.btn.has-icon .icon,.submit.has-icon .icon,.btn-large.has-icon .icon,.submit-large.has-icon .icon,.btn-large-secondary.has-icon .icon,.dark-button.has-icon .icon,.cc-btn.has-icon .icon,.btn.has-icon .loading-indicator,.submit.has-icon .loading-indicator,.btn-large.has-icon .loading-indicator,.submit-large.has-icon .loading-indicator,.btn-large-secondary.has-icon .loading-indicator,.dark-button.has-icon .loading-indicator,.cc-btn.has-icon .loading-indicator {position: absolute;left: 15px;top: calc(50% - 8px);}.btn.has-icon .btn-content,.submit.has-icon .btn-content,.btn-large.has-icon .btn-content,.submit-large.has-icon .btn-content,.btn-large-secondary.has-icon .btn-content,.dark-button.has-icon .btn-content,.cc-btn.has-icon .btn-content {position: relative;display: inline-block;}.btn.has-icon .btn-content .icon,.submit.has-icon .btn-content .icon,.btn-large.has-icon .btn-content .icon,.submit-large.has-icon .btn-content .icon,.btn-large-secondary.has-icon .btn-content .icon,.dark-button.has-icon .btn-content .icon,.cc-btn.has-icon .btn-content .icon,.btn.has-icon .btn-content .loading-indicator,.submit.has-icon .btn-content .loading-indicator,.btn-large.has-icon .btn-content .loading-indicator,.submit-large.has-icon .btn-content .loading-indicator,.btn-large-secondary.has-icon .btn-content .loading-indicator,.dark-button.has-icon .btn-content .loading-indicator,.cc-btn.has-icon .btn-content .loading-indicator {left: -26px;}.btn.has-icon.right,.submit.has-icon.right,.btn-large.has-icon.right,.submit-large.has-icon.right,.btn-large-secondary.has-icon.right,.dark-button.has-icon.right,.cc-btn.has-icon.right {padding-left: 15px;padding-right: 41px;}.btn.has-icon.right .icon,.submit.has-icon.right .icon,.btn-large.has-icon.right .icon,.submit-large.has-icon.right .icon,.btn-large-secondary.has-icon.right .icon,.dark-button.has-icon.right .icon,.cc-btn.has-icon.right .icon {right: 15px;left: initial;}.btn small,.submit small,.btn-large small,.submit-large small,.btn-large-secondary small,.dark-button small,.cc-btn small {margin-left: 10px;font-size: 12px;opacity: 0.67;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=67)";filter: alpha(opacity=67);}.btn small.dates,.submit small.dates,.btn-large small.dates,.submit-large small.dates,.btn-large-secondary small.dates,.dark-button small.dates,.cc-btn small.dates {font-size: 11px;}.submit,.submit-large {color: #fff;background: #0c92f3;border: 1px solid #0c92f3;}.submit .icon >path,.submit-large .icon >path {fill: #fff;}.submit:hover,.submit-large:hover {color: #fff;background: #007fd9;border: 1px solid #0c92f3;}.submit:active,.submit-large:active {background: #1a1b1c;border-color: #1a1b1c;}.submit:active .icon >path,.submit-large:active .icon >path {fill: #fff;}.submit:focus,.submit-large:focus {outline-color: #064979;}.btn-large,.btn-large-secondary {padding: 10px 15px;}.submit-large {padding: 10px 15px;}.btn-large-secondary {background: #969799;color: #fff;border: 1px solid #969799;}.btn-large-secondary:hover {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary:active {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary .icon >path {fill: #e3e4e6;}a.btn,a.btn-large {color: #555659;}a.submit,a.submit-large,a.btn-large-secondary {color: #fff;}.dark-button {background: #2c2e2f;border: 1px solid rgba(106,124,131,0.75);color: #e3e4e6;-webkit-transition: background-color 0.15s;-moz-transition: background-color 0.15s;-o-transition: background-color 0.15s;-ms-transition: background-color 0.15s;transition: background-color 0.15s;}.dark-button .icon >path {fill: #dcdcdc;}.dark-button.disabled,.dark-button:disabled {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;pointer-events: none;}.dark-button.disabled .icon > path,.dark-button:disabled .icon > path {fill: rgba(106,124,131,0.5);}.dark-button.disabled.has-tip,.dark-button:disabled.has-tip {pointer-events: auto;}.dark-button.disabled.has-tip:hover,.dark-button:disabled.has-tip:hover {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;}.dark-button.transparent {background-color: transparent;}.dark-button:hover {background: #1a1b1c;border-color: #7d8f95;color: #fcfcfc;}.dark-button:hover .icon > path {fill: #fff;}.dark-button:active {border-color: #dcdcdc;}.icon-only {position: relative;width: 32px;height: 30px;}.icon-only .icon {position: absolute;left: calc(50% - 8px);top: calc(50% - 8px);}.icon-only:hover .icon >path {fill: #555659;}.icon-only:active .icon >path {fill: #2c2e2f;}.icon-only.dark-button:hover .icon >path {fill: #fff;}.btn-invisible,.btn-no-style {color: #555659;padding: 5px 15px;border-color: transparent;-webkit-box-shadow: inset 0 0 0 1px transparent;box-shadow: inset 0 0 0 1px transparent;background: transparent;-webkit-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-moz-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-o-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-ms-transition: background 0.15s, box-shadow 0.15s, color 0.15s;transition: background 0.15s, box-shadow 0.15s, color 0.15s;}.btn-invisible.disabled,.btn-no-style.disabled,.btn-invisible:disabled,.btn-no-style:disabled {cursor: default;}.btn-no-style {padding: 5px 10px 5px 0;vertical-align: baseline;}.btn-no-style:hover {border-color: transparent;color: #555659;}.btn-no-style:focus {border-radius: 0;outline: none;}.btn-no-style.dark {color: #7d8f95;}.btn-no-style.dark:hover {color: #f9f9f9;}.btn-no-style.dark:active {background: transparent;border-color: transparent;color: #fff;}.btn-no-style .css-icon::before {right: 0;}.link {display: inline-block;position: relative;cursor: pointer;-webkit-transition: all 0.15s;-moz-transition: all 0.15s;-o-transition: all 0.15s;-ms-transition: all 0.15s;transition: all 0.15s;}.link.has-icon {padding-left: 20px;}.link.has-icon .icon {position: absolute;left: 0;top: calc(50% - 8px);}.link.has-icon .icon >path {fill: #969799;}.link.has-icon .icon-plus,.link.has-icon .icon-close,.link.has-icon .icon-delete {top: calc(50% - 10px);}.link.has-icon:hover .icon >path {fill: #555659;}.link.has-icon:active .icon >path {fill: #0c92f3;}.link.dark,.popup-content .link {color: #7d8f95;}.link.dark .icon >path,.popup-content .link .icon >path {fill: #7d8f95;}.link.dark:hover,.popup-content .link:hover {color: #dcdcdc;}.link.dark:hover .icon >path,.popup-content .link:hover .icon >path {fill: #dcdcdc;}.link.dark:active,.popup-content .link:active {color: #fff;}.link.secondary {color: #969799;}.link.secondary:hover {color: #555659;}button.icon-btn {border: 0;background: none;padding: 0;}button.icon-btn:active {outline: none;}.icon-btn {display: inline-block;margin-left: 10px;vertical-align: middle;}.icon-btn .icon {display: block;}.icon-btn .icon >path {fill: #969799;}.icon-btn:hover .icon >path {fill: #555659;}.icon-btn.dark .icon >path {fill: #6a7c83;}.icon-btn.dark:hover .icon >path {fill: #f9f9f9;}.link-bar {display: block;margin-top: 16px;white-space: nowrap;}.link-bar.no-margin {margin-top: 0;}.link-bar .submit,.link-bar .submit-large,.link-bar .dark-button {min-width: 120px;}.link-bar a,.link-bar button {vertical-align: baseline;}.link-bar.right,.link-bar.center {text-align: right;}.link-bar.right a,.link-bar.center a,.link-bar.right button,.link-bar.center button {margin-right: 15px;}.link-bar.right .btn,.link-bar.center .btn,.link-bar.right .dark-button,.link-bar.center .dark-button,.link-bar.right .submit,.link-bar.center .submit {margin-right: 10px;}.link-bar.right *:nth-last-child(1),.link-bar.center *:nth-last-child(1) {margin-right: 0;}.link-bar.left {text-align: left;}.link-bar.left a,.link-bar.left button {margin-left: 15px;}.link-bar.left .btn,.link-bar.left .dark-button,.link-bar.left .submit {margin-left: 10px;}.link-bar.left *:first-child {margin-left: 0;}.link-bar.center {text-align: center;}input[type=radio],input[type=checkbox] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 17px;height: 17px;position: relative;border: 1px solid #dcdcdc;margin: 0;background: #fff;cursor: pointer;}input[type=radio].disabled,input[type=checkbox].disabled,input[type=radio]:disabled,input[type=checkbox]:disabled {background: #e3e4e6;}input[type=radio].dark,input[type=checkbox].dark {background: rgba(106,124,131,0.2);border-color: rgba(106,124,131,0.8);}input[type=radio].dark:checked,input[type=checkbox].dark:checked {background: #dcdcdc;}input[type=radio].dark:focus,input[type=checkbox].dark:focus {background: #f9f9f9;}input[type=radio].dark:active,input[type=checkbox].dark:active {background: #fff;}input[type=radio].dark.disabled,input[type=checkbox].dark.disabled,input[type=radio].dark:disabled,input[type=checkbox].dark:disabled {background: rgba(106,124,131,0.5);}input[type=radio] {border-radius: 8.5px;}input[type=radio]:active {background: #dcdcdc;}input[type=radio]:checked::after {position: absolute;content: "";height: 9px;width: 9px;left: calc(50% - 4.5px);top: calc(50% - 4.5px);border-radius: 4.25px;background-color: #0c92f3;}input[type=checkbox] {border-radius: 3px;}input[type=checkbox]:active {background: #dcdcdc;}input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: 3%;height: 40%;width: 69%;border-bottom: 2px solid #0c92f3;border-left: 2px solid #0c92f3;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}input[type=submit] {height: inherit;}input.required-checkbox[type=checkbox]:hover::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);left: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAADe0lEQVRYCe2WW0jTYRTA3V3pZRWEJJJFUQQFRtCFogt7kV7cxVkGmlBPdoHepCh6CCHoJYIIyvlgLYdzUfjQnSjoQXpIYUSZ9aZQQmNzDHVbvzPa+O/bf9sf0Tf/8PF9536+c853zt9Us4RvZGTkuMlkeqOITrrd7m0KriporsqxwgyrDqxGYDUCVnlloVBoK1vC7/fPrPCrK6gPh8P70+n0WM4Bq9XaB8VDg3nPHlpcXAzjzO8C9zIdhoeH95rN5nbUtdHINmUyGZeV29cBtICUejgmC4fuRiKRdzAMQYt4PJ5Z8Ev6MNqMUT/CfnRt0SqxWCw+bFnF+BotAUYLsAtBF/s9IvOaPRSLxSLd3d1/tbx6Zy61C71yUzFatj1Dc5tQ/pjDKT1FKi6bzc6De8WaROaSlg5thnUffDtrh5ZW6WyFuQ7BNLvcuuIHjx2GE3pM0OpZ1/Vo5XDYnTUzwdypVKoB4DyMH1jZcgLLhJcUDmCvZXx8vN6kKiV/DRRHG/k/CW2fSl8KjLEE0XnGs3tCYb/ghUkqc1+JA3mC7MFgsMlut0shSV73aGkGzkkMj8pLisfjoxRvSk+mogNaAWlWRKaLyFzV4tUzRqfAXUkkEs87OzvnVLoKG54FhE0qf62qQAduhG/KiHGRNewADaUVxT06BotQ8NhADAUCAWcRoQxgyAFqoZHQP9TT8T/kKqnJ6XQGVKQeXNUBcm+pra19xM3WqQowPsg6xNKbG62086JmpcoLXNUBWuo1+A7rCP9KJpM9Xq93mko/A72kf+DYLRlAOrIFVMVXQJs+Audbbl/kKIrT4I8ypD7mNcF7G77LeViz/1xYWGimiGMaXOFYpLiA5YDC9WwS+hIeHOjTGhc5Rngv22c5K99motiv4ApgifICpaamH+MNGjh3xPjYxMTEDRUv3Y2bSveMqzT0ePgBuaDiBdZNgTBT9Xd0BOZop80+n++7Di2HInKnMTio0nF8HvxBRk9RlEocoOq322y2LyhwqEootnMU3QMVr8I4MYCxLhWPEz9I1U7tLChJQTQaldv1wZxRFDw1YlxkaMM9yH9T5CU1vVrjQi+JQF6INLi4hRThBpRNM7J3d3R0/MnTq+3yK8bs+ASfRDJK6ryk7qsqV9YBYaQDbnQ4HEGcuEnuXqrC1WBScRGeA0TkrNHZUE3nstP/Ae08V3wBOebTAAAAAElFTkSuQmCC");background-position: 50% 50%;}input.required-checkbox[type=checkbox]:checked {border: none;background: #f26161;}input.required-checkbox[type=checkbox]:checked:hover {background: #d95757;}input.required-checkbox[type=checkbox]:checked:disabled {background: #f8b0b0;cursor: auto;}input[type=checkbox].required-checkbox:checked::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABtklEQVRIDe2UzStEYRSHZwxpwpSNlNQUEQsbSztK7BUmbKzITvkPWMjKjpSywlIpSc1CkWxkQ5IslCQpHwvCeM6k27nnvnfuhKyceu49H79z3vv5xmJFWi6X2wBtjcW0lhQj+onmf4HIp/c3j4hPYxjqIi+nSAGzyqAXWmIc0iD2AbswAbV2FrmCnyn1UuiGJbgDsXlZYDLv+g/vhFkYgxpZjHNgAXIJ6IQFuAVrV9K4b7MmfiPegTOTXye+MblAGCfTzwUOQg+Uw2/ZCYPWvGEslIIR2IRX+I6d0zQNbd5gl4OgGkZhG+QRFbJLirPQ7poVmaNRvoww26IQjxwSJqC5Ak7Dpn/lh8L6I/MMWDbDX4gPTO6RuDlymBXQlDGDJJyCGriWQNkxftLOCI0RN8CDGiBuFvJ7F+cukJ9R22LoQF2gQ/aRQ92Jfw/1RjdjNBJmtMbpI5pzNMrP6DM0svfsGa28jyafUAcU5dZl09O2ojXaR5QGuTttRwQJrfN8CpWwqtQX+ClP4HCo9yn9E/6AQ+ZPIRqHZ+jwV9wROtlN5X9pdSscWcT5bdpRCqTQJqEqUCDxCYHVRpVrffeeAAAAAElFTkSuQmCC");background-position: 50% 50%;}input::placeholder,textarea::placeholder {color: #969799;}input:-ms-input-placeholder,textarea:-ms-input-placeholder {color: #969799;}.classic-input,.large-input {-webkit-transition: border-color 0.15s, background 0.15s;-moz-transition: border-color 0.15s, background 0.15s;-o-transition: border-color 0.15s, background 0.15s;-ms-transition: border-color 0.15s, background 0.15s;transition: border-color 0.15s, background 0.15s;border: 1px solid #e3e4e6;background-color: #fff;padding: 4px 10px;border-radius: 3px;}.classic-input.invalid,.large-input.invalid {border: 1px solid #d94141;}.classic-input.invalid:focus,.large-input.invalid:focus {outline: none;}.classic-input.invalid:hover,.large-input.invalid:hover {border: 1px solid #d94141;}.classic-input:hover,.large-input:hover {background-color: #fff;border-color: rgba(12,146,243,0.5);}.classic-input:active,.large-input:active,.classic-input:focus,.large-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #fff;border-color: #0c92f3;}.classic-input.disabled,.large-input.disabled,.classic-input:disabled,.large-input:disabled {background: #f9f9f9;color: #969799;}.classic-input.disabled:hover,.large-input.disabled:hover,.classic-input:disabled:hover,.large-input:disabled:hover,.classic-input.disabled:active,.large-input.disabled:active,.classic-input:disabled:active,.large-input:disabled:active {border-color: #e3e4e6;}.classic-input::-ms-clear,.large-input::-ms-clear {display: none;}textarea.classic-input {resize: vertical;}.hoverable-input {-webkit-transition: border-color 0.3s, background-color 0.3s;-moz-transition: border-color 0.3s, background-color 0.3s;-o-transition: border-color 0.3s, background-color 0.3s;-ms-transition: border-color 0.3s, background-color 0.3s;transition: border-color 0.3s, background-color 0.3s;border: 1px solid transparent;background-color: transparent;padding: 4px 10px;border-radius: 3px;}.hoverable-input.invalid {border: 1px solid #d94141;outline: none;}.hoverable-input:hover {background-color: #fff;border-color: #e3e4e6;}.hoverable-input:active,.hoverable-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #f9f9f9;border-color: #e3e4e6;}.dark-input,.large-input.dark {height: 30px;color: #f9f9f9;padding: 4px 10px;background: rgba(106,124,131,0.5);border: none;color: #e3e4e6;border-radius: 3px;}.dark-input.invalid,.large-input.dark.invalid {border: 1px solid #d94141;}.dark-input.invalid:focus,.large-input.dark.invalid:focus {outline: none;}.dark-input.invalid:hover,.large-input.dark.invalid:hover {border: 1px solid #d94141;}.dark-input:hover,.large-input.dark:hover {background: #6a7c83;}.dark-input:focus,.large-input.dark:focus {background: #fff;color: #555659;outline: none;}textarea.dark-input {height: auto;}.large-input {height: 40px;}.large-input.dark {height: 40px;}.no-input {background: none;border: none;outline: none;-webkit-box-shadow: none;box-shadow: none;margin: 0;padding: 0;resize: none;}.no-input.dark {color: #f9f9f9;}.options-list {list-style-type: none;}.options-list li {margin-bottom: 8px;}.options-list li.list-padding {margin-bottom: 16px;}.options-list label {display: block;position: relative;cursor: pointer;}.options-list label input[type=checkbox],.options-list label input[type=radio] {position: absolute;}.options-list label input[type=checkbox] ~ span,.options-list label input[type=radio] ~ span,.options-list label input[type=checkbox] ~ p,.options-list label input[type=radio] ~ p {padding-left: 26px;display: block;color: #555659;}.options-list label input[type=checkbox]:checked ~ span,.options-list label input[type=radio]:checked ~ span,.options-list label input[type=checkbox]:checked ~ p,.options-list label input[type=radio]:checked ~ p {color: #555659;}.popup-content .options-list input[type="checkbox"],.sheets-content .options-list input[type="checkbox"],.modal-legacy.dark .options-list input[type="checkbox"],.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {background: rgba(106,124,131,0.5);border-color: rgba(106,124,131,0.8);}.popup-content .options-list input[type="checkbox"] ~ span,.sheets-content .options-list input[type="checkbox"] ~ span,.modal-legacy.dark .options-list input[type="checkbox"] ~ span,.popup-content .options-list input[type="radio"] ~ span,.sheets-content .options-list input[type="radio"] ~ span,.modal-legacy.dark .options-list input[type="radio"] ~ span,.popup-content .options-list input[type="checkbox"] ~ p,.sheets-content .options-list input[type="checkbox"] ~ p,.modal-legacy.dark .options-list input[type="checkbox"] ~ p,.popup-content .options-list input[type="radio"] ~ p,.sheets-content .options-list input[type="radio"] ~ p,.modal-legacy.dark .options-list input[type="radio"] ~ p {color: #a4b0b4;}.popup-content .options-list input[type="checkbox"]:checked,.sheets-content .options-list input[type="checkbox"]:checked,.modal-legacy.dark .options-list input[type="checkbox"]:checked,.popup-content .options-list input[type="radio"]:checked,.sheets-content .options-list input[type="radio"]:checked,.modal-legacy.dark .options-list input[type="radio"]:checked {background: #dcdcdc;}.popup-content .options-list input[type="checkbox"]:checked ~ span,.sheets-content .options-list input[type="checkbox"]:checked ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ span,.popup-content .options-list input[type="radio"]:checked ~ span,.sheets-content .options-list input[type="radio"]:checked ~ span,.modal-legacy.dark .options-list input[type="radio"]:checked ~ span,.popup-content .options-list input[type="checkbox"]:checked ~ p,.sheets-content .options-list input[type="checkbox"]:checked ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ p,.popup-content .options-list input[type="radio"]:checked ~ p,.sheets-content .options-list input[type="radio"]:checked ~ p,.modal-legacy.dark .options-list input[type="radio"]:checked ~ p {color: #f9f9f9;}.popup-content .options-list input[type="checkbox"]:focus,.sheets-content .options-list input[type="checkbox"]:focus,.modal-legacy.dark .options-list input[type="checkbox"]:focus,.popup-content .options-list input[type="radio"]:focus,.sheets-content .options-list input[type="radio"]:focus,.modal-legacy.dark .options-list input[type="radio"]:focus {background: #f9f9f9;}.popup-content .options-list input[type="checkbox"].disabled,.sheets-content .options-list input[type="checkbox"].disabled,.modal-legacy.dark .options-list input[type="checkbox"].disabled,.popup-content .options-list input[type="radio"].disabled,.sheets-content .options-list input[type="radio"].disabled,.modal-legacy.dark .options-list input[type="radio"].disabled,.popup-content .options-list input[type="checkbox"]:disabled,.sheets-content .options-list input[type="checkbox"]:disabled,.modal-legacy.dark .options-list input[type="checkbox"]:disabled,.popup-content .options-list input[type="radio"]:disabled,.sheets-content .options-list input[type="radio"]:disabled,.modal-legacy.dark .options-list input[type="radio"]:disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="checkbox"].disabled ~ span,.sheets-content .options-list input[type="checkbox"].disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ span,.popup-content .options-list input[type="radio"].disabled ~ span,.sheets-content .options-list input[type="radio"].disabled ~ span,.modal-legacy.dark .options-list input[type="radio"].disabled ~ span,.popup-content .options-list input[type="checkbox"]:disabled ~ span,.sheets-content .options-list input[type="checkbox"]:disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ span,.popup-content .options-list input[type="radio"]:disabled ~ span,.sheets-content .options-list input[type="radio"]:disabled ~ span,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ span,.popup-content .options-list input[type="checkbox"].disabled ~ p,.sheets-content .options-list input[type="checkbox"].disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ p,.popup-content .options-list input[type="radio"].disabled ~ p,.sheets-content .options-list input[type="radio"].disabled ~ p,.modal-legacy.dark .options-list input[type="radio"].disabled ~ p,.popup-content .options-list input[type="checkbox"]:disabled ~ p,.sheets-content .options-list input[type="checkbox"]:disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ p,.popup-content .options-list input[type="radio"]:disabled ~ p,.sheets-content .options-list input[type="radio"]:disabled ~ p,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ p {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {border-radius: 8.5px;}.loading-indicator {display: inline-block;border-radius: 30px;-webkit-animation: loading 1.2s infinite linear;-moz-animation: loading 1.2s infinite linear;-o-animation: loading 1.2s infinite linear;-ms-animation: loading 1.2s infinite linear;animation: loading 1.2s infinite linear;width: 30px;height: 30px;border: 4px solid #0c92f3;border-top: 4px solid #e3e4e6;border-left: 4px solid #e3e4e6;vertical-align: middle;}.loading-indicator.small {margin-right: 10px;width: 16px;height: 16px;border: 2px solid #0c92f3;border-top: 2px solid #e3e4e6;border-left: 2px solid #e3e4e6;}.loading-indicator.small.completed {border: 2px solid #555659;}.loading-indicator.small.completed .icon {vertical-align: top;width: 10px;height: 10px;}.loading-indicator.completed {border: 4px solid #555659;text-align: center;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;}.loading-indicator .icon {margin-left: 1px;height: 100%;vertical-align: middle;}.loading-indicator .icon >path {fill: #39bf87;}.loading-indicator.fadein {-webkit-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-moz-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-o-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-ms-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}.css-icon {display: inline-block;width: 16px;height: 1px;}.css-icon::before {position: absolute;display: block;content: "";right: 10px;top: calc(50% - 8px);width: 16px;height: 16px;}.css-icon-plus::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path d='M7.5,3h1v4.5H13v1H8.5V13h-1V8.5H3v-1h4.5V3z'></path></svg>") no-repeat 0 0;}.css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23979797' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.btn-no-style.dark:hover .css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23DCDCDC' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.toggle-label {clear: left;color: #969799;line-height: 22px;}.toggle-label button {float: left;margin-right: 10px;}.toggle-slider {margin-left: 10px;background: #fff;width: 45px;height: 22px;border-radius: 11px;position: relative;vertical-align: middle;border: 1px solid #dcdcdc;-webkit-transition: background 150ms;-moz-transition: background 150ms;-o-transition: background 150ms;-ms-transition: background 150ms;transition: background 150ms;}.toggle-slider:focus {outline: none;}.toggle-slider:hover {background-color: #f9f9f9;}.toggle-slider .ball {height: 16px;width: 16px;border-radius: 8px;position: absolute;background-color: #dcdcdc;left: 2px;top: 2px;right: auto;-webkit-transition: 150ms;-moz-transition: 150ms;-o-transition: 150ms;-ms-transition: 150ms;transition: 150ms;}.toggle-slider .ball:hover {background: #969799;}.toggle-slider.on .ball {left: 25px;background: #39bf87;}.toggle-slider.on .ball:hover {background: #30a272;}.message-banner {position: relative;display: inline-block;margin-bottom: 20px;padding: 9px 15px;border-radius: 3px;background: #e1f3ff;color: #6a7c83;}.message-banner.full-width {display: block;}.message-banner.centered {text-align: center;}.message-banner.has-icon {padding-left: 41px;}.message-banner.has-dismiss {padding-right: 41px;}.message-banner.has-dismiss .icon-btn {position: absolute;right: 15px;top: 6px;}.message-banner.has-dismiss .icon-btn .icon {position: relative;left: inherit;top: inherit;}.message-banner.has-button {padding-top: 14px;padding-right: 180px;padding-bottom: 14px;}.message-banner.has-button .icon {top: 15px;}.message-banner.has-button .btn,.message-banner.has-button button {position: absolute;right: 10px;top: 10px;}.message-banner a,.message-banner a:visited {color: #555659;}.message-banner a:hover,.message-banner a:visited:hover {color: #1a1b1c;}.message-banner .icon {position: absolute;left: 15px;top: 10px;}.message-banner .icon >path {fill: #6a7c83;}.message-banner .label {color: #555659;}.message-banner .btn {float: right;}.message-banner.warning {background: #fec;}.message-banner.error {background: #ffe6e6;color: #555659;}.message-banner.error .label {color: #555659;}.message-banner.error .icon >path {fill: #555659;}.what-is-this {display: inline-block;color: #969799;cursor: default;padding-left: 4px;font-size: 12px;}.what-is-this.dark {color: #6a7c83;}.what-is-this.dark:hover {color: #f9f9f9;}.what-is-this .icon >path {fill: #969799;}.what-is-this:hover {color: #555659;}.what-is-this:hover .icon >path {fill: #555659;}.what-is-this-icon {display: inline-block;margin-left: 10px;}.what-is-this-icon .icon {width: 12px;height: 12px;}.what-is-this-icon .icon >path {fill: #969799;}.what-is-this-icon:hover .icon >path {fill: #555659;}.what-is-this-icon.no-margin {margin-left: 4px;}.what-is-this-icon.dark .icon >path {fill: #6a7c83;}.what-is-this-icon.dark:hover .icon >path {fill: #dde5e7;}.gated-feature,.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter,.gated-feature-block,.gated-feature-block-pro {position: relative;cursor: pointer;background: rgba(227,228,230,0.5);}.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before {content: 'Enterprise';font-size: 12px;color: #fff;background-color: #39bf87;border-radius: 3px;padding: 2px 10px;position: absolute;right: 15px;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {cursor: pointer;content: '';border-radius: 3px;border: 1px solid #e3e4e6;}.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter {border: 1px solid #e3e4e6;border-radius: 3px;}.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before {content: 'Enterprise';position: absolute;float: right;top: 50%;-webkit-transform: translateY(-50%);-moz-transform: translateY(-50%);-o-transform: translateY(-50%);-ms-transform: translateY(-50%);transform: translateY(-50%);margin-left: 10px;}.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after {content: none;display: none;}.gated-feature-inline *,.gated-feature-inline-enterprise *,.gated-feature-inline-professional *,.gated-feature-inline-starter * {pointer-events: none;}.gated-feature-inline-professional:before {content: 'Pro';}.gated-feature-inline-starter:before {content: 'Starter';}.gated-feature-block,.gated-feature-block-pro {margin-top: 32px;padding: 15px 15px;}.gated-feature-block:before,.gated-feature-block-pro:before {top: 15px;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;}.gated-feature-block:after,.gated-feature-block-pro:after {pointer-events: none;}.gated-feature-block-pro:before {content: 'Pro';}.gated-ad {max-width: 600px;min-height: 270px;}.gated-ad .pull-left {float: left;margin-right: 70px;}.gated-ad div.pull-left,.gated-ad div.image {margin-top: 25px;}.gated-ad ul li {margin: 0 0 32px 0;list-style: none;}.gated-ad ul li .icon {vertical-align: sub;margin-right: 10px;}.gated-ad ul li .icon > path {fill: #969799;}.momentum-body,.badge,.theme-inverse .button.button-link,.button.button-link,.font-base {font-family: 'Meta', sans-serif;letter-spacing: 0;text-transform: none;}.momentum-body .icon,.badge .icon,.theme-inverse .button.button-link .icon,.button.button-link .icon,.font-base .icon,.momentum-body .momentum-body .icon,.momentum-body .badge .icon,.momentum-body .theme-inverse .button.button-link .icon,.momentum-body .button.button-link .icon,.momentum-body .font-base .icon {vertical-align: -0.15em;}.momentum-body {color: #222326;font-size: 16px;font-weight: normal;line-height: 24px;margin: 0;}.button,.mo-identicon-initials,.col-list-row-header,.nav-link,.font-caps {font-family: 'Meta-Caps', 'Meta', sans-serif;letter-spacing: 1px;text-transform: lowercase;}.button .icon,.mo-identicon-initials .icon,.col-list-row-header .icon,.nav-link .icon,.font-caps .icon,.momentum-body .button .icon,.momentum-body .mo-identicon-initials .icon,.momentum-body .col-list-row-header .icon,.momentum-body .nav-link .icon,.momentum-body .font-caps .icon {vertical-align: -0.188em;}.form-control,.font-inherit {font-family: inherit;letter-spacing: inherit;text-transform: inherit;}.theme-inverse .button {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.theme-inverse,.theme-inverse .text-base,.theme-inverse .text-small,.theme-inverse .text-caption {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5,.momentum-body b,.momentum-body strong,.text-h1,.text-h2,.text-h3,.text-h3_5,.text-h4,.text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5,.theme-inverse b,.theme-inverse strong,.theme-inverse .text-h1,.theme-inverse .text-h2,.theme-inverse .text-h3,.theme-inverse .text-h3_5,.theme-inverse .text-h4,.theme-inverse .text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse {background-color: #3b3d3f;color: #d7d7d9;}.card {border-radius: 3px;-webkit-box-shadow: 0 1px 1px rgba(0,0,0,0.15);box-shadow: 0 1px 1px rgba(0,0,0,0.15);}.momentum-body p {margin-bottom: 16px;margin-top: 0;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5 {color: #222326;font-weight: bold;margin-bottom: 8px;margin-top: 0;text-transform: none;}.momentum-body h1 {font-size: 40px;line-height: 48px;}.momentum-body h2 {font-size: 32px;line-height: 40px;}.momentum-body h3 {font-size: 24px;line-height: 36px;}.momentum-body h4 {font-size: 16px;letter-spacing: 0;font-family: 'Meta', sans-serif;line-height: 24px;}.momentum-body h5 {font-size: 14px;line-height: 21px;}.momentum-body small {font-size: 14px;line-height: 21px;}.momentum-body ol,.momentum-body ul {margin-bottom: 16px;margin-top: 0;padding-left: 16px;}.momentum-body ol ol,.momentum-body ul ol,.momentum-body ol ul,.momentum-body ul ul {margin-bottom: 0;}.momentum-body b,.momentum-body strong {font-weight: bolder;}.momentum-body a {-webkit-text-decoration-skip: objects;background-color: transparent;color: inherit;text-decoration: underline;}.momentum-body a:visited {color: inherit;}.momentum-body a:hover {color: #0068b3;}.momentum-body a:active {color: #003459;}.momentum-body a.strikethrough {text-decoration: line-through;}.momentum-body a.text-muted {color: #555659;}.momentum-body a.text-decoration-none {text-decoration: none;}.momentum-body a.underline-on-hover {text-decoration: none;}.momentum-body a.underline-on-hover:hover,.momentum-body a.underline-on-hover:active,.momentum-body a.underline-on-hover:focus {text-decoration: underline;}.momentum-body hr {background: #e3e4e6;border: none;height: 1px;margin-bottom: 4px;margin-top: 3px;}.momentum-body section {margin-bottom: 32px;}.momentum-body input[type=text] {height: auto;}.momentum-body button {cursor: pointer;}.momentum-body .icon {display: inline-block;height: 16px;margin-left: 8px;margin-right: 8px;width: 16px;}.momentum-body .icon:not(.icon-ms-teams) > path {fill: currentColor;}.momentum-body .icon:first-child {margin-left: 0;}.momentum-body .icon:last-child {margin-right: 0;}.momentum-body .icon-large {height: 24px;margin-left: 8px;margin-right: 8px;width: 24px;}.momentum-body .icon-small {height: 14px;width: 14px;margin-left: 8px;margin-right: 8px;}.momentum-body .icon-caption {height: 12px;width: 12px;margin-left: 4px;margin-right: 4px;}.momentum-body .icon-thumbnail {height: 48px;margin-left: $iconThumbnailMarginX;margin-right: $iconThumbnailMarginX;width: 48px;}.badge {border-radius: 3px;display: inline-block;font-size: 14px;height: 20px;line-height: 20px;margin-left: 8px;margin-right: 8px;min-width: 20px;padding-left: 4px;padding-right: 4px;text-align: center;}.badge:first-child {margin-left: 0;}.badge:last-child {margin-right: 0;}.badge {background-color: #e3e4e6;color: #969799;}.theme-inverse .badge {background-color: #555659;color: #d7d7d9;}.theme-inverse .badge.badge-default {background-color: #e3e4e6;color: #969799;}.badge.badge-primary {background-color: #0c92f3;color: #fff;}.badge.badge-secondary {background-color: #969799;color: #fff;}.badge.badge-positive {background-color: #39bf71;color: #fff;}.badge.badge-negative {background-color: #d94141;color: #fff;}.badge.badge-inverse {background-color: #555659;color: #d7d7d9;}.badge.badge-white {background-color: #fff;color: #555659;}.badge.badge-gray {background-color: #969799;color: #fff;}.badge.badge-black {background-color: #000;color: #fff;}.badge.badge-small {font-size: 12px;height: 18px;line-height: 18px;min-width: 18px;}.badge.badge-caption {font-size: 12px;height: 16px;line-height: 16px;min-width: 16px;}.button,a.button {background-color: #fff;background-image: -webkit-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -moz-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -o-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -ms-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);border: 1px solid rgba(215,215,217,0.7);color: #555659;padding: 7px 15px;}.button:hover,a.button:hover,.button.hover,a.button.hover {background-color: #fff;border-color: #b1b1b3;color: #555659;}.button:focus,a.button:focus,.button.focus,a.button.focus {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.button:active,a.button:active,.button.active,a.button.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #222326;}.button.selected,a.button.selected {background-color: #e3e4e6;color: #222326;}.button[disabled],a.button[disabled],.button.disabled,a.button.disabled {cursor: not-allowed;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.button[disabled]:hover,a.button[disabled]:hover,.button.disabled:hover,a.button.disabled:hover,.button[disabled]:active,a.button[disabled]:active,.button.disabled:active,a.button.disabled:active {background-color: #fff;background-image: $buttonBackgroundGradient;border-color: rgba(215,215,217,0.7);color: #555659;}.button.button-square,a.button.button-square {padding: 7px 11px;}.button.button-lg,a.button.button-lg {padding: 5px 15px;}.button.button-lg.button-square,a.button.button-lg.button-square {padding: 5px 14px;}.button.button-sm,a.button.button-sm {padding: 3px 15px;}.button.button-sm.button-square,a.button.button-sm.button-square {padding: 3px 8px;}.button-group .button:hover,.button-group a.button:hover {border-right-width: 1px;}.button-group .button:hover + .button,.button-group a.button:hover + .button {margin-left: 0;border-left-width: 0;}.button {border-radius: 3px;cursor: pointer;display: inline-block;font-size: 14px;line-height: 24px;margin-right: 8px;text-align: center;-webkit-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;}.button,.momentum-body .button {text-decoration: none;}.button:last-child {margin-right: 0;}.button .icon {margin-left: 12px;margin-right: 12px;opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);-webkit-transition: opacity 0.15s ease-in-out;-moz-transition: opacity 0.15s ease-in-out;-o-transition: opacity 0.15s ease-in-out;-ms-transition: opacity 0.15s ease-in-out;transition: opacity 0.15s ease-in-out;}.button .icon:first-child {margin-left: 0;}.button .icon:last-child {margin-right: 0;}.theme-inverse .button {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.theme-inverse .button .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button:visited {color: #fff;}.theme-inverse .button:hover,.theme-inverse .button.hover {background-color: #707173;border-color: #969799;color: #fff;}.theme-inverse .button:hover .icon,.theme-inverse .button.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.theme-inverse .button:active,.theme-inverse .button.active {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button.selected {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button[disabled]:hover,.theme-inverse .button.disabled:hover,.theme-inverse .button[disabled]:active,.theme-inverse .button.disabled:active {background-color: #555659;background-image: none;color: #fff;}.theme-inverse .button[disabled]:hover .icon,.theme-inverse .button.disabled:hover .icon,.theme-inverse .button[disabled]:active .icon,.theme-inverse .button.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button.button-square {padding: 8px 12px;}.theme-inverse .button.button-lg {padding: 6px 16px;}.theme-inverse .button.button-lg.button-square {padding: 6px 15px;}.theme-inverse .button.button-sm {padding: 4px 16px;}.theme-inverse .button.button-sm.button-square {padding: 4px 9px;}.button-group .theme-inverse .button:hover {border-right-width: 0;}.button-group .theme-inverse .button:hover + .button {margin-left: -1px;border-left-width: 1px;}.theme-inverse .button.button-link {border: none;background-color: transparent;background-image: none;color: #969799;padding: 0;text-decoration: underline;text-transform: none;}.theme-inverse .button.button-link:visited {color: #969799;}.theme-inverse .button.button-link:hover {color: #d7d7d9;}.theme-inverse .button.button-link:active {color: #0c92f3;}.theme-inverse .button.button-link.text-decoration-none {text-decoration: none;}.button.button-link {border: none;background-color: transparent;background-image: none;color: inherit;padding: 0;text-decoration: underline;text-transform: none;}.button.button-link:visited {color: inherit;}.button.button-link:hover {color: #0068b3;border: none;background-color: transparent;background-image: none;}.button.button-link:active {color: #003459;}.button.button-link.text-decoration-none {text-decoration: none;}.button.button-primary,.button.button-blue {background-color: #0c92f3;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-primary .icon,.button.button-blue .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:visited,.button.button-blue:visited {color: #fff;}.button.button-primary:hover,.button.button-blue:hover,.button.button-primary.hover,.button.button-blue.hover {background-color: #007fd9;border-color: #fff;color: #fff;}.button.button-primary:hover .icon,.button.button-blue:hover .icon,.button.button-primary.hover .icon,.button.button-blue.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:active,.button.button-blue:active,.button.button-primary.active,.button.button-blue.active {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary.selected,.button.button-blue.selected {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary[disabled]:hover,.button.button-blue[disabled]:hover,.button.button-primary.disabled:hover,.button.button-blue.disabled:hover,.button.button-primary[disabled]:active,.button.button-blue[disabled]:active,.button.button-primary.disabled:active,.button.button-blue.disabled:active {background-color: #0c92f3;background-image: none;color: #fff;}.button.button-primary[disabled]:hover .icon,.button.button-blue[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-blue.disabled:hover .icon,.button.button-primary[disabled]:active .icon,.button.button-blue[disabled]:active .icon,.button.button-primary.disabled:active .icon,.button.button-blue.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary.button-square,.button.button-blue.button-square {padding: 8px 12px;}.button.button-primary.button-lg,.button.button-blue.button-lg {padding: 6px 16px;}.button.button-primary.button-lg.button-square,.button.button-blue.button-lg.button-square {padding: 6px 15px;}.button.button-primary.button-sm,.button.button-blue.button-sm {padding: 4px 16px;}.button.button-primary.button-sm.button-square,.button.button-blue.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary:hover,.button-group .button.button-blue:hover {border-right-width: 0;}.button-group .button.button-primary:hover + .button,.button-group .button.button-blue:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-primary[disabled],.button.button-primary.disabled {background-color: #e3e4e6;background-image: none;border-color: #d7d7d9;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-primary[disabled] .icon,.button.button-primary.disabled .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled]:visited,.button.button-primary.disabled:visited {color: #555659;}.button.button-primary[disabled]:hover,.button.button-primary.disabled:hover,.button.button-primary[disabled].hover,.button.button-primary.disabled.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-primary[disabled].hover .icon,.button.button-primary.disabled.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary[disabled]:active,.button.button-primary.disabled:active,.button.button-primary[disabled].active,.button.button-primary.disabled.active {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled].selected,.button.button-primary.disabled.selected {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled][disabled]:hover,.button.button-primary.disabled[disabled]:hover,.button.button-primary[disabled].disabled:hover,.button.button-primary.disabled.disabled:hover,.button.button-primary[disabled][disabled]:active,.button.button-primary.disabled[disabled]:active,.button.button-primary[disabled].disabled:active,.button.button-primary.disabled.disabled:active {background-color: #e3e4e6;background-image: none;color: #555659;}.button.button-primary[disabled][disabled]:hover .icon,.button.button-primary.disabled[disabled]:hover .icon,.button.button-primary[disabled].disabled:hover .icon,.button.button-primary.disabled.disabled:hover .icon,.button.button-primary[disabled][disabled]:active .icon,.button.button-primary.disabled[disabled]:active .icon,.button.button-primary[disabled].disabled:active .icon,.button.button-primary.disabled.disabled:active .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled].button-square,.button.button-primary.disabled.button-square {padding: 8px 12px;}.button.button-primary[disabled].button-lg,.button.button-primary.disabled.button-lg {padding: 6px 16px;}.button.button-primary[disabled].button-lg.button-square,.button.button-primary.disabled.button-lg.button-square {padding: 6px 15px;}.button.button-primary[disabled].button-sm,.button.button-primary.disabled.button-sm {padding: 4px 16px;}.button.button-primary[disabled].button-sm.button-square,.button.button-primary.disabled.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary[disabled]:hover,.button-group .button.button-primary.disabled:hover {border-right-width: 0;}.button-group .button.button-primary[disabled]:hover + .button,.button-group .button.button-primary.disabled:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-positive,.button.button-green {background-color: #39bf71;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-positive .icon,.button.button-green .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:visited,.button.button-green:visited {color: #fff;}.button.button-positive:hover,.button.button-green:hover,.button.button-positive.hover,.button.button-green.hover {background-color: #19a654;border-color: #fff;color: #fff;}.button.button-positive:hover .icon,.button.button-green:hover .icon,.button.button-positive.hover .icon,.button.button-green.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:active,.button.button-green:active,.button.button-positive.active,.button.button-green.active {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive.selected,.button.button-green.selected {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive[disabled]:hover,.button.button-green[disabled]:hover,.button.button-positive.disabled:hover,.button.button-green.disabled:hover,.button.button-positive[disabled]:active,.button.button-green[disabled]:active,.button.button-positive.disabled:active,.button.button-green.disabled:active {background-color: #39bf71;background-image: none;color: #fff;}.button.button-positive[disabled]:hover .icon,.button.button-green[disabled]:hover .icon,.button.button-positive.disabled:hover .icon,.button.button-green.disabled:hover .icon,.button.button-positive[disabled]:active .icon,.button.button-green[disabled]:active .icon,.button.button-positive.disabled:active .icon,.button.button-green.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive.button-square,.button.button-green.button-square {padding: 8px 12px;}.button.button-positive.button-lg,.button.button-green.button-lg {padding: 6px 16px;}.button.button-positive.button-lg.button-square,.button.button-green.button-lg.button-square {padding: 6px 15px;}.button.button-positive.button-sm,.button.button-green.button-sm {padding: 4px 16px;}.button.button-positive.button-sm.button-square,.button.button-green.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-positive:hover,.button-group .button.button-green:hover {border-right-width: 0;}.button-group .button.button-positive:hover + .button,.button-group .button.button-green:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-negative,.button.button-red {background-color: #d94141;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-negative .icon,.button.button-red .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:visited,.button.button-red:visited {color: #fff;}.button.button-negative:hover,.button.button-red:hover,.button.button-negative.hover,.button.button-red.hover {background-color: #bf3939;border-color: #fff;color: #fff;}.button.button-negative:hover .icon,.button.button-red:hover .icon,.button.button-negative.hover .icon,.button.button-red.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:active,.button.button-red:active,.button.button-negative.active,.button.button-red.active {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative.selected,.button.button-red.selected {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative[disabled]:hover,.button.button-red[disabled]:hover,.button.button-negative.disabled:hover,.button.button-red.disabled:hover,.button.button-negative[disabled]:active,.button.button-red[disabled]:active,.button.button-negative.disabled:active,.button.button-red.disabled:active {background-color: #d94141;background-image: none;color: #fff;}.button.button-negative[disabled]:hover .icon,.button.button-red[disabled]:hover .icon,.button.button-negative.disabled:hover .icon,.button.button-red.disabled:hover .icon,.button.button-negative[disabled]:active .icon,.button.button-red[disabled]:active .icon,.button.button-negative.disabled:active .icon,.button.button-red.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative.button-square,.button.button-red.button-square {padding: 8px 12px;}.button.button-negative.button-lg,.button.button-red.button-lg {padding: 6px 16px;}.button.button-negative.button-lg.button-square,.button.button-red.button-lg.button-square {padding: 6px 15px;}.button.button-negative.button-sm,.button.button-red.button-sm {padding: 4px 16px;}.button.button-negative.button-sm.button-square,.button.button-red.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-negative:hover,.button-group .button.button-red:hover {border-right-width: 0;}.button-group .button.button-negative:hover + .button,.button-group .button.button-red:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-inverse,.button.button-gray {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-inverse .icon,.button.button-gray .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse:visited,.button.button-gray:visited {color: #fff;}.button.button-inverse:hover,.button.button-gray:hover,.button.button-inverse.hover,.button.button-gray.hover {background-color: #707173;border-color: #969799;color: #fff;}.button.button-inverse:hover .icon,.button.button-gray:hover .icon,.button.button-inverse.hover .icon,.button.button-gray.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-inverse:active,.button.button-gray:active,.button.button-inverse.active,.button.button-gray.active {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse.selected,.button.button-gray.selected {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse[disabled]:hover,.button.button-gray[disabled]:hover,.button.button-inverse.disabled:hover,.button.button-gray.disabled:hover,.button.button-inverse[disabled]:active,.button.button-gray[disabled]:active,.button.button-inverse.disabled:active,.button.button-gray.disabled:active {background-color: #555659;background-image: none;color: #fff;}.button.button-inverse[disabled]:hover .icon,.button.button-gray[disabled]:hover .icon,.button.button-inverse.disabled:hover .icon,.button.button-gray.disabled:hover .icon,.button.button-inverse[disabled]:active .icon,.button.button-gray[disabled]:active .icon,.button.button-inverse.disabled:active .icon,.button.button-gray.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse.button-square,.button.button-gray.button-square {padding: 8px 12px;}.button.button-inverse.button-lg,.button.button-gray.button-lg {padding: 6px 16px;}.button.button-inverse.button-lg.button-square,.button.button-gray.button-lg.button-square {padding: 6px 15px;}.button.button-inverse.button-sm,.button.button-gray.button-sm {padding: 4px 16px;}.button.button-inverse.button-sm.button-square,.button.button-gray.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-inverse:hover,.button-group .button.button-gray:hover {border-right-width: 0;}.button-group .button.button-inverse:hover + .button,.button-group .button.button-gray:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet {background-color: #a452cc;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-violet .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:visited {color: #fff;}.button.button-violet:hover,.button.button-violet.hover {background-color: #9c2bd4;border-color: #fff;color: #fff;}.button.button-violet:hover .icon,.button.button-violet.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:active,.button.button-violet.active {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet.selected {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet[disabled]:hover,.button.button-violet.disabled:hover,.button.button-violet[disabled]:active,.button.button-violet.disabled:active {background-color: #a452cc;background-image: none;color: #fff;}.button.button-violet[disabled]:hover .icon,.button.button-violet.disabled:hover .icon,.button.button-violet[disabled]:active .icon,.button.button-violet.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet.button-square {padding: 8px 12px;}.button.button-violet.button-lg {padding: 6px 16px;}.button.button-violet.button-lg.button-square {padding: 6px 15px;}.button.button-violet.button-sm {padding: 4px 16px;}.button.button-violet.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet:hover {border-right-width: 0;}.button-group .button.button-violet:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet-light {background-color: #f5e0ff;background-image: none;border-color: #f5e0ff;border-width: 0;color: #620e8c;padding: 8px 16px;}.button.button-violet-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light:visited {color: #620e8c;}.button.button-violet-light:hover,.button.button-violet-light.hover {background-color: #ebc4ff;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light:hover .icon,.button.button-violet-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet-light:active,.button.button-violet-light.active {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light.selected {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light[disabled]:hover,.button.button-violet-light.disabled:hover,.button.button-violet-light[disabled]:active,.button.button-violet-light.disabled:active {background-color: #f5e0ff;background-image: none;color: #620e8c;}.button.button-violet-light[disabled]:hover .icon,.button.button-violet-light.disabled:hover .icon,.button.button-violet-light[disabled]:active .icon,.button.button-violet-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light.button-square {padding: 8px 12px;}.button.button-violet-light.button-lg {padding: 6px 16px;}.button.button-violet-light.button-lg.button-square {padding: 6px 15px;}.button.button-violet-light.button-sm {padding: 4px 16px;}.button.button-violet-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet-light:hover {border-right-width: 0;}.button-group .button.button-violet-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-blue-light {background-color: #e1f3ff;background-image: none;border-color: #e1f3ff;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-blue-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light:visited {color: #555659;}.button.button-blue-light:hover,.button.button-blue-light.hover {background-color: #bfe5ff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light:hover .icon,.button.button-blue-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-blue-light:active,.button.button-blue-light.active {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light.selected {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light[disabled]:hover,.button.button-blue-light.disabled:hover,.button.button-blue-light[disabled]:active,.button.button-blue-light.disabled:active {background-color: #e1f3ff;background-image: none;color: #555659;}.button.button-blue-light[disabled]:hover .icon,.button.button-blue-light.disabled:hover .icon,.button.button-blue-light[disabled]:active .icon,.button.button-blue-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light.button-square {padding: 8px 12px;}.button.button-blue-light.button-lg {padding: 6px 16px;}.button.button-blue-light.button-lg.button-square {padding: 6px 15px;}.button.button-blue-light.button-sm {padding: 4px 16px;}.button.button-blue-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-blue-light:hover {border-right-width: 0;}.button-group .button.button-blue-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-turquoise {background-color: #1cadba;background-image: none;border-color: #1cadba;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-turquoise .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise:visited {color: #555659;}.button.button-turquoise:hover,.button.button-turquoise.hover {background-color: #0097a6;border-color: #1cadba;color: #555659;}.button.button-turquoise:hover .icon,.button.button-turquoise.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-turquoise:active,.button.button-turquoise.active {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise.selected {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise[disabled]:hover,.button.button-turquoise.disabled:hover,.button.button-turquoise[disabled]:active,.button.button-turquoise.disabled:active {background-color: #1cadba;background-image: none;color: #555659;}.button.button-turquoise[disabled]:hover .icon,.button.button-turquoise.disabled:hover .icon,.button.button-turquoise[disabled]:active .icon,.button.button-turquoise.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise.button-square {padding: 8px 12px;}.button.button-turquoise.button-lg {padding: 6px 16px;}.button.button-turquoise.button-lg.button-square {padding: 6px 15px;}.button.button-turquoise.button-sm {padding: 4px 16px;}.button.button-turquoise.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-turquoise:hover {border-right-width: 0;}.button-group .button.button-turquoise:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-yellow {background-color: #ffa60d;background-image: none;border-color: #ffa60d;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-yellow .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow:visited {color: #fff;}.button.button-yellow:hover,.button.button-yellow.hover {background-color: #ff9000;border-color: #ffa60d;color: #fff;}.button.button-yellow:hover .icon,.button.button-yellow.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-yellow:active,.button.button-yellow.active {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow.selected {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow[disabled]:hover,.button.button-yellow.disabled:hover,.button.button-yellow[disabled]:active,.button.button-yellow.disabled:active {background-color: #ffa60d;background-image: none;color: #fff;}.button.button-yellow[disabled]:hover .icon,.button.button-yellow.disabled:hover .icon,.button.button-yellow[disabled]:active .icon,.button.button-yellow.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow.button-square {padding: 8px 12px;}.button.button-yellow.button-lg {padding: 6px 16px;}.button.button-yellow.button-lg.button-square {padding: 6px 15px;}.button.button-yellow.button-sm {padding: 4px 16px;}.button.button-yellow.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-yellow:hover {border-right-width: 0;}.button-group .button.button-yellow:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-black {background-color: #000;background-image: none;border-color: #000;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-black .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black:visited {color: #fff;}.button.button-black:hover,.button.button-black.hover {background-color: #3b3d3f;border-color: #000;color: #fff;}.button.button-black:hover .icon,.button.button-black.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-black:active,.button.button-black.active {background-color: #555659;border-color: #000;color: #fff;}.button.button-black.selected {background-color: #555659;border-color: #000;color: #fff;}.button.button-black[disabled]:hover,.button.button-black.disabled:hover,.button.button-black[disabled]:active,.button.button-black.disabled:active {background-color: #000;background-image: none;color: #fff;}.button.button-black[disabled]:hover .icon,.button.button-black.disabled:hover .icon,.button.button-black[disabled]:active .icon,.button.button-black.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black.button-square {padding: 8px 12px;}.button.button-black.button-lg {padding: 6px 16px;}.button.button-black.button-lg.button-square {padding: 6px 15px;}.button.button-black.button-sm {padding: 4px 16px;}.button.button-black.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-black:hover {border-right-width: 0;}.button-group .button.button-black:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-lg {border-radius: 3px;font-size: 18px;line-height: 36px;}.button.button-lg .icon,.momentum-body .button.button-lg .icon {height: 18px;width: 18px;}.button.button-sm {border-radius: 3px;font-size: 14px;line-height: 24px;}.button.button-sm .icon,.momentum-body .button.button-sm .icon {height: 14px;width: 14px;}.button-group {margin-right: 8px;}.button-group:last-child {margin-right: 0;}.button-group .button {border-radius: 0;margin-right: 0;}.button-group .button:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.button-group .button:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.button-group .button + .button {border-left-width: 1px;margin-left: -1px;}.button-circle {border-radius: 50%;background-color: #fff;border: 0;padding: 12px 0;color: #969799;height: 46px;width: 46px;line-height: 23px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.button-circle >.icon {height: 23px;width: 23px;margin: auto;}.button-circle:hover {color: #fff;background-color: #0c92f3;}.button-circle,a.button-circle {display: inline-block;background: #fff;}.button-circle,.momentum-body .button-circle {text-decoration: none;}.button-circle.button-shadow {-webkit-box-shadow: 0px 1px 4px rgba(0,0,0,0.25);box-shadow: 0px 1px 4px rgba(0,0,0,0.25);}.button-circle.button-circle-sm {height: 28px;width: 28px;line-height: 14px;padding: 6px 7px 6px 5px;}.button-circle.button-circle-sm >.icon {height: 14px;width: 14px;}.button-circle.button-circle-lg {height: 56px;width: 56px;line-height: 28px;padding: 13px 0;}.button-circle.button-circle-lg >.icon {height: 28px;width: 28px;}.card {background-color: #fff;border: 1px solid #f0f1f2;padding: 16px;width: 100%;}.centered-content {align-items: center;display: flex;justify-content: center;}.ol-chain-list {padding: 8px 16px;border-radius: 3px;}.ol-chain-list .ol-chain-separator:not(:last-child) {border-bottom: 1px solid #d7d7d9;border-color: #d7d7d9;}.ol-chain-list .ol-chain-link {position: relative;padding: 8px 0;margin-left: 40px;}.ol-chain-list .ol-chain-link:before {position: absolute;top: 8px;bottom: -8px;border-color: #d7d7d9;border-style: dashed;border-width: 0 0 0 1px;content: "";left: -28px;}.ol-chain-list .ol-chain-link:last-child:before {display: none;}.ol-chain-list .ol-chain-link .ol-chain-counter {border: 1px solid #d7d7d9;border-radius: 50%;}.ol-chain-list .ol-chain-link .ol-chain-icon {align-items: center;display: flex;justify-content: center;padding-bottom: 4px;padding-top: 4px;}.ol-chain-list .ol-chain-link .ol-chain-counter,.ol-chain-list .ol-chain-link .ol-chain-icon {position: absolute;left: -40px;width: 24px;height: 24px;background: #fff;text-align: center;font-size: 14px;}.ol-chain-list .ol-chain-link .ol-chain-counter.optional,.ol-chain-list .ol-chain-link .ol-chain-icon.optional {border: 1px dotted #d7d7d9;}.ol-chain-list .ol-chain-link .ol-chain-content {width: 70%;}.ol-chain-list .ol-chain-link .ol-chain-content-100 {width: 100%;}.ol-chain-list .ol-chain-link .ol-chain-content-distributed {display: flex;justify-content: space-between;}.chip {border-radius: 12px;border-style: solid;border-width: 1px;display: inline-block;font-size: 14px;line-height: 14px;height: 24px;margin: 1px 4px 3px;max-width: 100%;overflow: hidden;padding: 4px 7px;-o-text-overflow: ellipsis;text-overflow: ellipsis;-webkit-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-moz-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-o-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-ms-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;vertical-align: middle;white-space: nowrap;}.chip,.momentum-body .chip {text-decoration: none;}.chip.chip-box {border-radius: 3px;}.chip:first-child {margin-left: 0;}.chip:last-child {margin-right: 0;}.chip + .chip {margin-left: 0;}.chip .icon {height: 1em;width: 1em;}.chip .icon,.chip .icon.momentum-body {margin-left: 0.5em;margin-right: 0.5em;}.chip > .close {color: inherit;}.chip > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 8px;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip > .close:hover {color: inherit;}.chip > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip > .close:active {color: inherit;}.chip > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip,.momentum-body  .chip {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}a.chip:hover,button.chip:hover,.chip.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}a.chip:active,button.chip:active,.chip.active {background-color: #b1b1b3;border-color: #b1b1b3;color: #555659;}a.chip:focus,button.chip:focus,.chip.focus {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip[disabled],.chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip[disabled]:hover,.chip.disabled:hover,.chip[disabled]:active,.chip.disabled:active {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined,.momentum-body  .chip.chip-outlined {background-color: #fff;border-color: #e3e4e6;color: #555659;}a.chip.chip-outlined:hover,button.chip.chip-outlined:hover,.chip.chip-outlined.hover {background-color: #f0f1f2;border-color: #d7d7d9;color: #555659;}a.chip.chip-outlined:active,button.chip.chip-outlined:active,.chip.chip-outlined.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #555659;}a.chip.chip-outlined:focus,button.chip.chip-outlined:focus,.chip.chip-outlined.focus {background-color: #fff;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined[disabled],.chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-outlined[disabled]:hover,.chip.chip-outlined.disabled:hover,.chip.chip-outlined[disabled]:active,.chip.chip-outlined.disabled:active {background-color: #fff;border-color: #e3e4e6;color: #555659;}.theme-inverse .chip,.momentum-body .theme-inverse .chip {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse a.chip:hover,.theme-inverse button.chip:hover,.theme-inverse .chip.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}.theme-inverse a.chip:active,.theme-inverse button.chip:active,.theme-inverse .chip.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip:focus,.theme-inverse button.chip:focus,.theme-inverse .chip.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip[disabled],.theme-inverse .chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip[disabled]:hover,.theme-inverse .chip.disabled:hover,.theme-inverse .chip[disabled]:active,.theme-inverse .chip.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip.chip-outlined,.momentum-body .theme-inverse .chip.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse a.chip.chip-outlined:hover,.theme-inverse button.chip.chip-outlined:hover,.theme-inverse .chip.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:active,.theme-inverse button.chip.chip-outlined:active,.theme-inverse .chip.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:focus,.theme-inverse button.chip.chip-outlined:focus,.theme-inverse .chip.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse .chip.chip-outlined[disabled],.theme-inverse .chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip.chip-outlined[disabled]:hover,.theme-inverse .chip.chip-outlined.disabled:hover,.theme-inverse .chip.chip-outlined[disabled]:active,.theme-inverse .chip.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse,.momentum-body  .chip.chip-inverse {background-color: #555659;border-color: #555659;color: #f0f1f2;}a.chip.chip-inverse:hover,button.chip.chip-inverse:hover,.chip.chip-inverse.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}a.chip.chip-inverse:active,button.chip.chip-inverse:active,.chip.chip-inverse.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse:focus,button.chip.chip-inverse:focus,.chip.chip-inverse.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse[disabled],.chip.chip-inverse.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse[disabled]:hover,.chip.chip-inverse.disabled:hover,.chip.chip-inverse[disabled]:active,.chip.chip-inverse.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse.chip-outlined,.momentum-body  .chip.chip-inverse.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}a.chip.chip-inverse.chip-outlined:hover,button.chip.chip-inverse.chip-outlined:hover,.chip.chip-inverse.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:active,button.chip.chip-inverse.chip-outlined:active,.chip.chip-inverse.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:focus,button.chip.chip-inverse.chip-outlined:focus,.chip.chip-inverse.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse.chip-outlined[disabled],.chip.chip-inverse.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse.chip-outlined[disabled]:hover,.chip.chip-inverse.chip-outlined.disabled:hover,.chip.chip-inverse.chip-outlined[disabled]:active,.chip.chip-inverse.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-blue,.momentum-body  .chip.chip-blue {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}a.chip.chip-blue:hover,button.chip.chip-blue:hover,.chip.chip-blue.hover {background-color: #bfe5ff;border-color: #bfe5ff;color: #555659;}a.chip.chip-blue:active,button.chip.chip-blue:active,.chip.chip-blue.active {background-color: #a6daff;border-color: #a6daff;color: #555659;}a.chip.chip-blue:focus,button.chip.chip-blue:focus,.chip.chip-blue.focus {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue[disabled],.chip.chip-blue.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue[disabled]:hover,.chip.chip-blue.disabled:hover,.chip.chip-blue[disabled]:active,.chip.chip-blue.disabled:active {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue.chip-outlined,.momentum-body  .chip.chip-blue.chip-outlined {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:hover,button.chip.chip-blue.chip-outlined:hover,.chip.chip-blue.chip-outlined.hover {background-color: #bfe5ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:active,button.chip.chip-blue.chip-outlined:active,.chip.chip-blue.chip-outlined.active {background-color: #a6daff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:focus,button.chip.chip-blue.chip-outlined:focus,.chip.chip-blue.chip-outlined.focus {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue.chip-outlined[disabled],.chip.chip-blue.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue.chip-outlined[disabled]:hover,.chip.chip-blue.chip-outlined.disabled:hover,.chip.chip-blue.chip-outlined[disabled]:active,.chip.chip-blue.chip-outlined.disabled:active {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue-dark,.momentum-body  .chip.chip-blue-dark {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}a.chip.chip-blue-dark:hover,button.chip.chip-blue-dark:hover,.chip.chip-blue-dark.hover {background-color: #0068b3;border-color: #0068b3;color: #f3faff;}a.chip.chip-blue-dark:active,button.chip.chip-blue-dark:active,.chip.chip-blue-dark.active {background-color: #004a7f;border-color: #004a7f;color: #f3faff;}a.chip.chip-blue-dark:focus,button.chip.chip-blue-dark:focus,.chip.chip-blue-dark.focus {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark[disabled],.chip.chip-blue-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark[disabled]:hover,.chip.chip-blue-dark.disabled:hover,.chip.chip-blue-dark[disabled]:active,.chip.chip-blue-dark.disabled:active {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark.chip-outlined,.momentum-body  .chip.chip-blue-dark.chip-outlined {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:hover,button.chip.chip-blue-dark.chip-outlined:hover,.chip.chip-blue-dark.chip-outlined.hover {background-color: #0068b3;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:active,button.chip.chip-blue-dark.chip-outlined:active,.chip.chip-blue-dark.chip-outlined.active {background-color: #004a7f;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:focus,button.chip.chip-blue-dark.chip-outlined:focus,.chip.chip-blue-dark.chip-outlined.focus {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-blue-dark.chip-outlined[disabled],.chip.chip-blue-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark.chip-outlined[disabled]:hover,.chip.chip-blue-dark.chip-outlined.disabled:hover,.chip.chip-blue-dark.chip-outlined[disabled]:active,.chip.chip-blue-dark.chip-outlined.disabled:active {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-red,.momentum-body  .chip.chip-red {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}a.chip.chip-red:hover,button.chip.chip-red:hover,.chip.chip-red.hover {background-color: #ffbfbf;border-color: #ffbfbf;color: #555659;}a.chip.chip-red:active,button.chip.chip-red:active,.chip.chip-red.active {background-color: #f99;border-color: #f99;color: #555659;}a.chip.chip-red:focus,button.chip.chip-red:focus,.chip.chip-red.focus {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red[disabled],.chip.chip-red.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red[disabled]:hover,.chip.chip-red.disabled:hover,.chip.chip-red[disabled]:active,.chip.chip-red.disabled:active {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red.chip-outlined,.momentum-body  .chip.chip-red.chip-outlined {background-color: #ffe6e6;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:hover,button.chip.chip-red.chip-outlined:hover,.chip.chip-red.chip-outlined.hover {background-color: #ffbfbf;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:active,button.chip.chip-red.chip-outlined:active,.chip.chip-red.chip-outlined.active {background-color: #f99;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:focus,button.chip.chip-red.chip-outlined:focus,.chip.chip-red.chip-outlined.focus {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red.chip-outlined[disabled],.chip.chip-red.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red.chip-outlined[disabled]:hover,.chip.chip-red.chip-outlined.disabled:hover,.chip.chip-red.chip-outlined[disabled]:active,.chip.chip-red.chip-outlined.disabled:active {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red-dark,.momentum-body  .chip.chip-red-dark {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}a.chip.chip-red-dark:hover,button.chip.chip-red-dark:hover,.chip.chip-red-dark.hover {background-color: #a62929;border-color: #a62929;color: #fff7f7;}a.chip.chip-red-dark:active,button.chip.chip-red-dark:active,.chip.chip-red-dark.active {background-color: #801a1a;border-color: #801a1a;color: #fff7f7;}a.chip.chip-red-dark:focus,button.chip.chip-red-dark:focus,.chip.chip-red-dark.focus {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark[disabled],.chip.chip-red-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark[disabled]:hover,.chip.chip-red-dark.disabled:hover,.chip.chip-red-dark[disabled]:active,.chip.chip-red-dark.disabled:active {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark.chip-outlined,.momentum-body  .chip.chip-red-dark.chip-outlined {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:hover,button.chip.chip-red-dark.chip-outlined:hover,.chip.chip-red-dark.chip-outlined.hover {background-color: #a62929;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:active,button.chip.chip-red-dark.chip-outlined:active,.chip.chip-red-dark.chip-outlined.active {background-color: #801a1a;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:focus,button.chip.chip-red-dark.chip-outlined:focus,.chip.chip-red-dark.chip-outlined.focus {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-red-dark.chip-outlined[disabled],.chip.chip-red-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark.chip-outlined[disabled]:hover,.chip.chip-red-dark.chip-outlined.disabled:hover,.chip.chip-red-dark.chip-outlined[disabled]:active,.chip.chip-red-dark.chip-outlined.disabled:active {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-green,.momentum-body  .chip.chip-green {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}a.chip.chip-green:hover,button.chip.chip-green:hover,.chip.chip-green.hover {background-color: #b4f0a8;border-color: #b4f0a8;color: #555659;}a.chip.chip-green:active,button.chip.chip-green:active,.chip.chip-green.active {background-color: #8ae58a;border-color: #8ae58a;color: #555659;}a.chip.chip-green:focus,button.chip.chip-green:focus,.chip.chip-green.focus {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green[disabled],.chip.chip-green.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green[disabled]:hover,.chip.chip-green.disabled:hover,.chip.chip-green[disabled]:active,.chip.chip-green.disabled:active {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green.chip-outlined,.momentum-body  .chip.chip-green.chip-outlined {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:hover,button.chip.chip-green.chip-outlined:hover,.chip.chip-green.chip-outlined.hover {background-color: #b4f0a8;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:active,button.chip.chip-green.chip-outlined:active,.chip.chip-green.chip-outlined.active {background-color: #8ae58a;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:focus,button.chip.chip-green.chip-outlined:focus,.chip.chip-green.chip-outlined.focus {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green.chip-outlined[disabled],.chip.chip-green.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green.chip-outlined[disabled]:hover,.chip.chip-green.chip-outlined.disabled:hover,.chip.chip-green.chip-outlined[disabled]:active,.chip.chip-green.chip-outlined.disabled:active {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green-dark,.momentum-body  .chip.chip-green-dark {background-color: #19a654;border-color: #19a654;color: #e1fae5;}a.chip.chip-green-dark:hover,button.chip.chip-green-dark:hover,.chip.chip-green-dark.hover {background-color: #0e8c42;border-color: #0e8c42;color: #e1fae5;}a.chip.chip-green-dark:active,button.chip.chip-green-dark:active,.chip.chip-green-dark.active {background-color: #007343;border-color: #007343;color: #e1fae5;}a.chip.chip-green-dark:focus,button.chip.chip-green-dark:focus,.chip.chip-green-dark.focus {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark[disabled],.chip.chip-green-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark[disabled]:hover,.chip.chip-green-dark.disabled:hover,.chip.chip-green-dark[disabled]:active,.chip.chip-green-dark.disabled:active {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark.chip-outlined,.momentum-body  .chip.chip-green-dark.chip-outlined {background-color: #19a654;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:hover,button.chip.chip-green-dark.chip-outlined:hover,.chip.chip-green-dark.chip-outlined.hover {background-color: #0e8c42;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:active,button.chip.chip-green-dark.chip-outlined:active,.chip.chip-green-dark.chip-outlined.active {background-color: #007343;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:focus,button.chip.chip-green-dark.chip-outlined:focus,.chip.chip-green-dark.chip-outlined.focus {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-green-dark.chip-outlined[disabled],.chip.chip-green-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark.chip-outlined[disabled]:hover,.chip.chip-green-dark.chip-outlined.disabled:hover,.chip.chip-green-dark.chip-outlined[disabled]:active,.chip.chip-green-dark.chip-outlined.disabled:active {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-yellow,.momentum-body  .chip.chip-yellow {background-color: #fec;border-color: #fec;color: #555659;}a.chip.chip-yellow:hover,button.chip.chip-yellow:hover,.chip.chip-yellow.hover {background-color: #ffe5b2;border-color: #ffe5b2;color: #555659;}a.chip.chip-yellow:active,button.chip.chip-yellow:active,.chip.chip-yellow.active {background-color: #ffdf88;border-color: #ffdf88;color: #555659;}a.chip.chip-yellow:focus,button.chip.chip-yellow:focus,.chip.chip-yellow.focus {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow[disabled],.chip.chip-yellow.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow[disabled]:hover,.chip.chip-yellow.disabled:hover,.chip.chip-yellow[disabled]:active,.chip.chip-yellow.disabled:active {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow.chip-outlined,.momentum-body  .chip.chip-yellow.chip-outlined {background-color: #fec;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:hover,button.chip.chip-yellow.chip-outlined:hover,.chip.chip-yellow.chip-outlined.hover {background-color: #ffe5b2;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:active,button.chip.chip-yellow.chip-outlined:active,.chip.chip-yellow.chip-outlined.active {background-color: #ffdf88;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:focus,button.chip.chip-yellow.chip-outlined:focus,.chip.chip-yellow.chip-outlined.focus {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow.chip-outlined[disabled],.chip.chip-yellow.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow.chip-outlined[disabled]:hover,.chip.chip-yellow.chip-outlined.disabled:hover,.chip.chip-yellow.chip-outlined[disabled]:active,.chip.chip-yellow.chip-outlined.disabled:active {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow-dark,.momentum-body  .chip.chip-yellow-dark {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}a.chip.chip-yellow-dark:hover,button.chip.chip-yellow-dark:hover,.chip.chip-yellow-dark.hover {background-color: #e67600;border-color: #e67600;color: #fff6e5;}a.chip.chip-yellow-dark:active,button.chip.chip-yellow-dark:active,.chip.chip-yellow-dark.active {background-color: #cc5f00;border-color: #cc5f00;color: #fff6e5;}a.chip.chip-yellow-dark:focus,button.chip.chip-yellow-dark:focus,.chip.chip-yellow-dark.focus {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark[disabled],.chip.chip-yellow-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark[disabled]:hover,.chip.chip-yellow-dark.disabled:hover,.chip.chip-yellow-dark[disabled]:active,.chip.chip-yellow-dark.disabled:active {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined,.momentum-body  .chip.chip-yellow-dark.chip-outlined {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:hover,button.chip.chip-yellow-dark.chip-outlined:hover,.chip.chip-yellow-dark.chip-outlined.hover {background-color: #e67600;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:active,button.chip.chip-yellow-dark.chip-outlined:active,.chip.chip-yellow-dark.chip-outlined.active {background-color: #cc5f00;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:focus,button.chip.chip-yellow-dark.chip-outlined:focus,.chip.chip-yellow-dark.chip-outlined.focus {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined[disabled],.chip.chip-yellow-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark.chip-outlined[disabled]:hover,.chip.chip-yellow-dark.chip-outlined.disabled:hover,.chip.chip-yellow-dark.chip-outlined[disabled]:active,.chip.chip-yellow-dark.chip-outlined.disabled:active {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-violet,.momentum-body  .chip.chip-violet {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}a.chip.chip-violet:hover,button.chip.chip-violet:hover,.chip.chip-violet.hover {background-color: #ebc4ff;border-color: #ebc4ff;color: #555659;}a.chip.chip-violet:active,button.chip.chip-violet:active,.chip.chip-violet.active {background-color: #dea2fc;border-color: #dea2fc;color: #555659;}a.chip.chip-violet:focus,button.chip.chip-violet:focus,.chip.chip-violet.focus {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet[disabled],.chip.chip-violet.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet[disabled]:hover,.chip.chip-violet.disabled:hover,.chip.chip-violet[disabled]:active,.chip.chip-violet.disabled:active {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet.chip-outlined,.momentum-body  .chip.chip-violet.chip-outlined {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:hover,button.chip.chip-violet.chip-outlined:hover,.chip.chip-violet.chip-outlined.hover {background-color: #ebc4ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:active,button.chip.chip-violet.chip-outlined:active,.chip.chip-violet.chip-outlined.active {background-color: #dea2fc;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:focus,button.chip.chip-violet.chip-outlined:focus,.chip.chip-violet.chip-outlined.focus {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-violet.chip-outlined[disabled],.chip.chip-violet.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet.chip-outlined[disabled]:hover,.chip.chip-violet.chip-outlined.disabled:hover,.chip.chip-violet.chip-outlined[disabled]:active,.chip.chip-violet.chip-outlined.disabled:active {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-turquoise,.momentum-body  .chip.chip-turquoise {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}a.chip.chip-turquoise:hover,button.chip.chip-turquoise:hover,.chip.chip-turquoise.hover {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise:active,button.chip.chip-turquoise:active,.chip.chip-turquoise.active {background-color: #91eaf2;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise:focus,button.chip.chip-turquoise:focus,.chip.chip-turquoise.focus {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise[disabled],.chip.chip-turquoise.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise[disabled]:hover,.chip.chip-turquoise.disabled:hover,.chip.chip-turquoise[disabled]:active,.chip.chip-turquoise.disabled:active {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}.chip.chip-turquoise.chip-outlined,.momentum-body  .chip.chip-turquoise.chip-outlined {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise.chip-outlined:hover,button.chip.chip-turquoise.chip-outlined:hover,.chip.chip-turquoise.chip-outlined.hover {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise.chip-outlined:active,button.chip.chip-turquoise.chip-outlined:active,.chip.chip-turquoise.chip-outlined.active {background-color: #91eaf2;border-color: #33c0cd;color: #222326;}a.chip.chip-turquoise.chip-outlined:focus,button.chip.chip-turquoise.chip-outlined:focus,.chip.chip-turquoise.chip-outlined.focus {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}.chip.chip-turquoise.chip-outlined[disabled],.chip.chip-turquoise.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise.chip-outlined[disabled]:hover,.chip.chip-turquoise.chip-outlined.disabled:hover,.chip.chip-turquoise.chip-outlined[disabled]:active,.chip.chip-turquoise.chip-outlined.disabled:active {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise.closable.closable-wide > .close::after {color: #555659;}.chip.chip-turquoise.closable.closable-wide > .close:hover::after {background-color: #91eaf2;}.chip.chip-turquoise.closable.closable-wide > .close:active::after {background-color: #33c0cd;}.chip.chip-lg {border-radius: 16px;font-size: 16px;height: 32px;line-height: 16px;padding: 7px 11px;}.chip.chip-lg.chip-box {border-radius: 3px;}.chip.chip-lg > .close::after {font-size: 13px;margin-left: 8px;}.chip.chip-sm {border-radius: 8px;font-size: 12px;height: 16px;line-height: 12px;padding: 1px 7px;}.chip.chip-sm.chip-box {border-radius: 3px;}.chip.chip-sm > .close::after {font-size: 9px;margin-left: 4px;}.chip.closable {padding-right: 20px;position: relative;}.chip.closable.closable-wide {align-items: center;display: inline-flex;padding-right: 8px;}.chip.closable.closable-wide > .close {position: relative;right: auto;}.chip.closable.closable-wide > .close::after {align-items: center;border-radius: 3px;display: inline-flex;justify-content: center;margin-left: 8px;opacity: 1;-ms-filter: none;filter: none;height: 16px;width: 16px;}.chip.closable.closable-wide > .close:hover::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide > .close:focus::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide.chip-lg {padding-right: 8px;}.chip.closable.closable-wide.chip-lg > .close::after {margin-left: 8px;height: 20px;width: 20px;}.chip.closable.closable-wide.chip-sm {padding-right: 4px;}.chip.closable.closable-wide.chip-sm > .close::after {margin-left: 4px;height: 12px;width: 12px;}.chip.closable > .close {color: inherit;position: absolute;right: 8px;text-decoration: none;}.chip.closable > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 0;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip.closable > .close:hover {color: inherit;}.chip.closable > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip.closable > .close:active {color: inherit;}.chip.closable > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip.closable.chip-lg {padding-right: 22px;}.chip.closable.chip-lg > .close::after {font-size: 13px;}.chip.closable.chip-sm {padding-right: 19px;}.chip.closable.chip-sm > .close::after {font-size: 9px;}.display-on-hover .displayed-on-hover {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.display-on-hover:hover .displayed-on-hover {opacity: 1;-ms-filter: none;filter: none;-webkit-transition: opacity 200ms ease-in-out;-moz-transition: opacity 200ms ease-in-out;-o-transition: opacity 200ms ease-in-out;-ms-transition: opacity 200ms ease-in-out;transition: opacity 200ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-fast {-webkit-transition: opacity 100ms ease-in-out;-moz-transition: opacity 100ms ease-in-out;-o-transition: opacity 100ms ease-in-out;-ms-transition: opacity 100ms ease-in-out;transition: opacity 100ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-slow {-webkit-transition: opacity 500ms ease-in-out;-moz-transition: opacity 500ms ease-in-out;-o-transition: opacity 500ms ease-in-out;-ms-transition: opacity 500ms ease-in-out;transition: opacity 500ms ease-in-out;}.text-divider {display: flex;align-items: center;text-align: center;}.text-divider::before,.text-divider::after {content: '';flex: 1;border-bottom: 1px solid #e3e4e6;}.text-divider:not(:empty)::before {margin-right: 8px;}.text-divider:not(:empty)::after {margin-left: 8px;}.marginless-divider {border-bottom: 1px solid #e3e4e6;}.form-group {margin-bottom: 24px;}.form-group label {display: block;font-size: 16px;margin-bottom: 4px;color: #222326;line-height: 24px;}.form-control,.form-control[disabled]:hover,.form-control.disabled:hover,.form-control.form-control-outlined,.theme-inverse .form-control.form-control-outlined,.form-control.form-control-outlined[disabled]:hover,.theme-inverse .form-control.form-control-outlined[disabled]:hover,.form-control.form-control-outlined.disabled:hover,.theme-inverse .form-control.form-control-outlined.disabled:hover {background-color: #fff;border-color: #e3e4e6;color: #222326;}.form-control::placeholder,.form-control[disabled]:hover::placeholder,.form-control.disabled:hover::placeholder,.form-control.form-control-outlined::placeholder,.theme-inverse .form-control.form-control-outlined::placeholder,.form-control.form-control-outlined[disabled]:hover::placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover::placeholder,.form-control.form-control-outlined.disabled:hover::placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover::placeholder,.form-control .form-control-placeholder,.form-control[disabled]:hover .form-control-placeholder,.form-control.disabled:hover .form-control-placeholder,.form-control.form-control-outlined .form-control-placeholder,.theme-inverse .form-control.form-control-outlined .form-control-placeholder,.form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.form-control.form-control-outlined.disabled:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover .form-control-placeholder {color: #555659;}.form-control:hover,.form-control.hover,.form-control.form-control-transparent:hover,.form-control.form-control-transparent.hover,.form-control.form-control-outlined:hover,.theme-inverse .form-control.form-control-outlined:hover,.form-control.form-control-outlined.hover,.theme-inverse .form-control.form-control-outlined.hover {background-color: #fff;border-color: #b1b1b3;color: #222326;}.theme-inverse .form-control,.theme-inverse .form-control[disabled]:hover,.theme-inverse .form-control.disabled:hover {background-color: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);color: #d7d7d9;}.theme-inverse .form-control::placeholder,.theme-inverse .form-control[disabled]:hover::placeholder,.theme-inverse .form-control.disabled:hover::placeholder,.theme-inverse .form-control .form-control-placeholder,.theme-inverse .form-control[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.disabled:hover .form-control-placeholder {color: #b1b1b3;}.theme-inverse .form-control:hover,.theme-inverse .form-control.hover {background-color: rgba(215,215,217,0.4);border-color: rgba(215,215,217,0);color: #d7d7d9;}.form-control.invalid,.form-control.invalid[disabled]:hover,.form-control.invalid.disabled:hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.invalid::placeholder,.form-control.invalid[disabled]:hover::placeholder,.form-control.invalid.disabled:hover::placeholder,.form-control.invalid .form-control-placeholder,.form-control.invalid[disabled]:hover .form-control-placeholder,.form-control.invalid.disabled:hover .form-control-placeholder {color: #555659;}.form-control.invalid:hover,.form-control.invalid.hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid,.theme-inverse .form-control.invalid[disabled]:hover,.theme-inverse .form-control.invalid.disabled:hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid::placeholder,.theme-inverse .form-control.invalid[disabled]:hover::placeholder,.theme-inverse .form-control.invalid.disabled:hover::placeholder,.theme-inverse .form-control.invalid .form-control-placeholder,.theme-inverse .form-control.invalid[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.invalid.disabled:hover .form-control-placeholder {color: #f99;}.theme-inverse .form-control.invalid:hover,.theme-inverse .form-control.invalid.hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.form-control-transparent,.form-control.form-control-transparent[disabled]:hover,.form-control.form-control-transparent.disabled:hover {background-color: transparent;border-color: transparent;color: inherit;}.form-control:focus,.form-control.focus,.form-control.form-control-transparent:focus,.form-control.form-control-transparent.focus,.theme-inverse .form-control:focus,.theme-inverse .form-control.focus,.form-control.form-control-outlined:focus,.theme-inverse .form-control.form-control-outlined:focus,.form-control.form-control-outlined.focus,.theme-inverse .form-control.form-control-outlined.focus,.form-control.invalid:focus,.form-control.invalid.focus,.theme-inverse .form-control.invalid:focus,.theme-inverse .form-control.invalid.focus {background-color: #fff;border-color: #0c92f3;color: #222326;}.form-control:focus::placeholder,.form-control.focus::placeholder,.form-control.form-control-transparent:focus::placeholder,.form-control.form-control-transparent.focus::placeholder,.theme-inverse .form-control:focus::placeholder,.theme-inverse .form-control.focus::placeholder,.form-control.form-control-outlined:focus::placeholder,.theme-inverse .form-control.form-control-outlined:focus::placeholder,.form-control.form-control-outlined.focus::placeholder,.theme-inverse .form-control.form-control-outlined.focus::placeholder,.form-control.invalid:focus::placeholder,.form-control.invalid.focus::placeholder,.theme-inverse .form-control.invalid:focus::placeholder,.theme-inverse .form-control.invalid.focus::placeholder,.form-control:focus .form-control-placeholder,.form-control.focus .form-control-placeholder,.form-control.form-control-transparent:focus .form-control-placeholder,.form-control.form-control-transparent.focus .form-control-placeholder,.theme-inverse .form-control:focus .form-control-placeholder,.theme-inverse .form-control.focus .form-control-placeholder,.form-control.form-control-outlined:focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined:focus .form-control-placeholder,.form-control.form-control-outlined.focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.focus .form-control-placeholder,.form-control.invalid:focus .form-control-placeholder,.form-control.invalid.focus .form-control-placeholder,.theme-inverse .form-control.invalid:focus .form-control-placeholder,.theme-inverse .form-control.invalid.focus .form-control-placeholder {color: #555659;}.form-control-label,label.form-control-label {display: block;line-height: 24px;font-size: 16px;margin-bottom: 4px;color: #222326;}.form-control-helper-text {display: block;margin-bottom: 4px;color: #222326;font-size: 14px;line-height: 21px;}.theme-inverse .form-group label,.theme-inverse .form-control-label,.theme-inverse label.form-control-label,.theme-inverse .form-control-helper-text {color: #d7d7d9;}.form-control {border-radius: 3px;border-style: solid;border-width: 1px;display: block;font-size: 16px;line-height: 24px;padding: 7px 15px;resize: vertical;-webkit-transition: border-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out;width: 100%;}.form-control:focus,.form-control.focus {outline: 0;}.form-control[disabled],.form-control.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-control.multi-select-input {padding: 6px 15px;}input.form-control {height: 40px;}.form-control-inline {display: inline-block;width: auto;}.form-control-inherit {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;color: inherit;font-size: inherit;font-weight: inherit;line-height: inherit;margin: -1px -8px;padding: 0 7px;}.form-control-inherit,input.form-control-inherit {height: auto;}.form-control-inherit.form-control-inline {margin-left: 0;margin-right: 0;}.form-control-lg {border-radius: 3px;font-size: 32px;line-height: 40px;padding: 3px 15px;}input.form-control-lg {height: 48px;}.form-control-sm {border-radius: 3px;font-size: 14px;line-height: 21px;padding: 4.5px 15px;}.form-control-sm.multi-select-input {padding: 3.5px 15px;}input.form-control-sm {height: 32px;}.form-check {display: block;}.form-check + .form-check {margin-top: 8px;}.form-check.disabled,.form-check [disabled] {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-check-label {display: inline-block;min-height: 24px;padding-left: 24px;position: relative;vertical-align: top;}.form-check-label .form-text {margin-top: 0;}.form-group label.form-check-label {display: inline-block;margin-bottom: 0;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {-moz-appearance: none;-webkit-appearance: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;border-style: solid;border-width: 1px;display: inline-block;height: 16px;margin: 0;position: relative;vertical-align: -0.15em;width: 16px;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);}.form-check-input:hover,input[type=checkbox].form-check-input:hover,input[type=radio].form-check-input:hover,.form-check.hover .form-check-input,.form-check.hover input[type=checkbox].form-check-input,.form-check.hover input[type=radio].form-check-input {background: rgba(150,151,153,0.4);border-color: #b1b1b3;}.form-check-input:active,input[type=checkbox].form-check-input:active,input[type=radio].form-check-input:active,.form-check.active .form-check-input,.form-check.active input[type=checkbox].form-check-input,.form-check.active input[type=radio].form-check-input {background: rgba(112,113,115,0.4);border-color: #969799;}.form-check-input:checked,input[type=checkbox].form-check-input:checked,input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input:checked:hover,input[type=checkbox].form-check-input:checked:hover,input[type=radio].form-check-input:checked:hover,.form-check.hover .form-check-input:checked,.form-check.hover input[type=checkbox].form-check-input:checked,.form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.form-check-input:checked:active,input[type=checkbox].form-check-input:checked:active,input[type=radio].form-check-input:checked:active,.form-check.active .form-check-input:checked,.form-check.active input[type=checkbox].form-check-input:checked,.form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.form-check-input[disabled]:hover,input[type=checkbox].form-check-input[disabled]:hover,input[type=radio].form-check-input[disabled]:hover,.form-check-input:indeterminate:hover,input[type=checkbox].form-check-input:indeterminate:hover,input[type=radio].form-check-input:indeterminate:hover,.form-check.disabled .form-check-input:hover,.form-check.disabled input[type=checkbox].form-check-input:hover,.form-check.disabled input[type=radio].form-check-input:hover,.form-check-input[disabled]:active,input[type=checkbox].form-check-input[disabled]:active,input[type=radio].form-check-input[disabled]:active,.form-check-input:indeterminate:active,input[type=checkbox].form-check-input:indeterminate:active,input[type=radio].form-check-input:indeterminate:active,.form-check.disabled .form-check-input:active,.form-check.disabled input[type=checkbox].form-check-input:active,.form-check.disabled input[type=radio].form-check-input:active {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);cursor: default;}.form-check-input[disabled]:checked,input[type=checkbox].form-check-input[disabled]:checked,input[type=radio].form-check-input[disabled]:checked,.form-check-input:indeterminate:checked,input[type=checkbox].form-check-input:indeterminate:checked,input[type=radio].form-check-input:indeterminate:checked,.form-check.disabled .form-check-input:checked,.form-check.disabled input[type=checkbox].form-check-input:checked,.form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-label .form-check-input,.form-check-label input[type=checkbox].form-check-input,.form-check-label input[type=radio].form-check-input {left: 0;position: absolute;top: 3px;}.form-check-input:focus,input[type=checkbox].form-check-input:focus,input[type=radio].form-check-input:focus {outline: 0;}.theme-inverse .form-check-input,.theme-inverse input[type=checkbox].form-check-input,.theme-inverse input[type=radio].form-check-input {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;}.theme-inverse .form-check-input:hover,.theme-inverse input[type=checkbox].form-check-input:hover,.theme-inverse input[type=radio].form-check-input:hover,.theme-inverse .form-check.hover .form-check-input,.theme-inverse .form-check.hover input[type=checkbox].form-check-input,.theme-inverse .form-check.hover input[type=radio].form-check-input {background: $formCheckOutlinedHoverBackgroundInverse;border-color: $formCheckOutlinedHoverBorderColorInverse;}.theme-inverse .form-check-input:active,.theme-inverse input[type=checkbox].form-check-input:active,.theme-inverse input[type=radio].form-check-input:active,.theme-inverse .form-check.active .form-check-input,.theme-inverse .form-check.active input[type=checkbox].form-check-input,.theme-inverse .form-check.active input[type=radio].form-check-input {background: $formCheckOutlinedActiveBackgroundInverse;border-color: $formCheckOutlinedActiveBorderColorInverse;}.theme-inverse .form-check-input:checked,.theme-inverse input[type=checkbox].form-check-input:checked,.theme-inverse input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.theme-inverse .form-check-input:checked:hover,.theme-inverse input[type=checkbox].form-check-input:checked:hover,.theme-inverse input[type=radio].form-check-input:checked:hover,.theme-inverse .form-check.hover .form-check-input:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.theme-inverse .form-check-input:checked:active,.theme-inverse input[type=checkbox].form-check-input:checked:active,.theme-inverse input[type=radio].form-check-input:checked:active,.theme-inverse .form-check.active .form-check-input:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.theme-inverse .form-check-input[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input[disabled]:hover,.theme-inverse input[type=radio].form-check-input[disabled]:hover,.theme-inverse .form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input:hover,.theme-inverse .form-check-input[disabled]:active,.theme-inverse input[type=checkbox].form-check-input[disabled]:active,.theme-inverse input[type=radio].form-check-input[disabled]:active,.theme-inverse .form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input:active {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;cursor: default;}.theme-inverse .form-check-input[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input[disabled]:checked,.theme-inverse input[type=radio].form-check-input[disabled]:checked,.theme-inverse .form-check-input:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input:indeterminate:checked,.theme-inverse input[type=radio].form-check-input:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined,input[type=checkbox].form-check-input.form-check-input-outlined,input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #e3e4e6;}.form-check-input.form-check-input-outlined:hover,input[type=checkbox].form-check-input.form-check-input-outlined:hover,input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check.hover .form-check-input.form-check-input-outlined,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #b1b1b3;}.form-check-input.form-check-input-outlined:active,input[type=checkbox].form-check-input.form-check-input-outlined:active,input[type=radio].form-check-input.form-check-input-outlined:active,.form-check.active .form-check-input.form-check-input-outlined,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.active input[type=radio].form-check-input.form-check-input-outlined {background: #f0f1f2;border-color: #969799;}.form-check-input.form-check-input-outlined:checked,input[type=checkbox].form-check-input.form-check-input-outlined:checked,input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined:checked:hover,input[type=checkbox].form-check-input.form-check-input-outlined:checked:hover,input[type=radio].form-check-input.form-check-input-outlined:checked:hover,.form-check.hover .form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined:checked {background: #007fd9;}.form-check-input.form-check-input-outlined:checked:active,input[type=checkbox].form-check-input.form-check-input-outlined:checked:active,input[type=radio].form-check-input.form-check-input-outlined:checked:active,.form-check.active .form-check-input.form-check-input-outlined:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.active input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0068b3;}.form-check-input.form-check-input-outlined[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:hover,input[type=radio].form-check-input.form-check-input-outlined[disabled]:hover,.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check-input.form-check-input-outlined[disabled]:active,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:active,input[type=radio].form-check-input.form-check-input-outlined[disabled]:active,.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:active {background: #fff;border-color: #e3e4e6;cursor: default;}.form-check-input.form-check-input-outlined[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:checked,input[type=radio].form-check-input.form-check-input-outlined[disabled]:checked,.form-check-input.form-check-input-outlined:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:checked,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.4945L7.97802 2.21978L4.85714 3.27472V0H3.53846V3.27472L0.417582 2.21978L0 3.4945L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.4945Z' fill='%23B1B1B3'/%3E%3C/svg%3E%0A");padding: 3px;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:hover,input[type=checkbox].form-check-input.form-check-input-required:hover,input[type=radio].form-check-input.form-check-input-required:hover,.form-check.hover .form-check-input.form-check-input-required,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required,.form-check.hover input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:active,input[type=checkbox].form-check-input.form-check-input-required:active,input[type=radio].form-check-input.form-check-input-required:active,.form-check.active .form-check-input.form-check-input-required,.form-check.active input[type=checkbox].form-check-input.form-check-input-required,.form-check.active input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked:hover,input[type=checkbox].form-check-input.form-check-input-required:checked:hover,input[type=radio].form-check-input.form-check-input-required:checked:hover,.form-check.hover .form-check-input.form-check-input-required:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-required:checked {background: #d94141;}.form-check-input.form-check-input-required:checked:active,input[type=checkbox].form-check-input.form-check-input-required:checked:active,input[type=radio].form-check-input.form-check-input-required:checked:active,.form-check.active .form-check-input.form-check-input-required:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.active input[type=radio].form-check-input.form-check-input-required:checked {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #f26161;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #d94141;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #bf3939;}.form-check-input.form-check-input-required[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-required[disabled]:hover,input[type=radio].form-check-input.form-check-input-required[disabled]:hover,.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-required:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:hover,.form-check-input.form-check-input-required[disabled]:active,input[type=checkbox].form-check-input.form-check-input-required[disabled]:active,input[type=radio].form-check-input.form-check-input-required[disabled]:active,.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-required:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:active {background: ;border-color: ;cursor: default;}.form-check-input.form-check-input-required[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-required[disabled]:checked,input[type=radio].form-check-input.form-check-input-required[disabled]:checked,.form-check-input.form-check-input-required:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:checked,input[type=radio].form-check-input.form-check-input-required:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-required:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.49451L7.97802 2.21978L4.85714 3.27473V0H3.53846V3.27473L0.417582 2.21978L0 3.49451L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.49451Z' fill='white'/%3E%3C/svg%3E%0A");}.form-check-input.invalid,input[type=checkbox].form-check-input.invalid,input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.form-check-input.invalid:hover,input[type=checkbox].form-check-input.invalid:hover,input[type=radio].form-check-input.invalid:hover,.form-check.hover .form-check-input.invalid,.form-check.hover input[type=checkbox].form-check-input.invalid,.form-check.hover input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.form-check-input.invalid:active,input[type=checkbox].form-check-input.invalid:active,input[type=radio].form-check-input.invalid:active,.form-check.active .form-check-input.invalid,.form-check.active input[type=checkbox].form-check-input.invalid,.form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.form-check-input.invalid:checked,input[type=checkbox].form-check-input.invalid:checked,input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.form-check-input.invalid:checked:hover,input[type=checkbox].form-check-input.invalid:checked:hover,input[type=radio].form-check-input.invalid:checked:hover,.form-check.hover .form-check-input.invalid:checked,.form-check.hover input[type=checkbox].form-check-input.invalid:checked,.form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.form-check-input.invalid:checked:active,input[type=checkbox].form-check-input.invalid:checked:active,input[type=radio].form-check-input.invalid:checked:active,.form-check.active .form-check-input.invalid:checked,.form-check.active input[type=checkbox].form-check-input.invalid:checked,.form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.form-check-input.invalid[disabled]:hover,input[type=checkbox].form-check-input.invalid[disabled]:hover,input[type=radio].form-check-input.invalid[disabled]:hover,.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.disabled .form-check-input.invalid:hover,.form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.form-check.disabled input[type=radio].form-check-input.invalid:hover,.form-check-input.invalid[disabled]:active,input[type=checkbox].form-check-input.invalid[disabled]:active,input[type=radio].form-check-input.invalid[disabled]:active,.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=radio].form-check-input.invalid:indeterminate:active,.form-check.disabled .form-check-input.invalid:active,.form-check.disabled input[type=checkbox].form-check-input.invalid:active,.form-check.disabled input[type=radio].form-check-input.invalid:active {background: #fff7f7;border-color: #d94141;cursor: default;}.form-check-input.invalid[disabled]:checked,input[type=checkbox].form-check-input.invalid[disabled]:checked,input[type=radio].form-check-input.invalid[disabled]:checked,.form-check-input.invalid:indeterminate:checked,input[type=checkbox].form-check-input.invalid:indeterminate:checked,input[type=radio].form-check-input.invalid:indeterminate:checked,.form-check.disabled .form-check-input.invalid:checked,.form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid,.theme-inverse input[type=checkbox].form-check-input.invalid,.theme-inverse input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.theme-inverse .form-check-input.invalid:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:hover,.theme-inverse input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check.hover .form-check-input.invalid,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.theme-inverse .form-check-input.invalid:active,.theme-inverse input[type=checkbox].form-check-input.invalid:active,.theme-inverse input[type=radio].form-check-input.invalid:active,.theme-inverse .form-check.active .form-check-input.invalid,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.theme-inverse .form-check-input.invalid:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:checked,.theme-inverse input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid:checked:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:hover,.theme-inverse input[type=radio].form-check-input.invalid:checked:hover,.theme-inverse .form-check.hover .form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.theme-inverse .form-check-input.invalid:checked:active,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:active,.theme-inverse input[type=radio].form-check-input.invalid:checked:active,.theme-inverse .form-check.active .form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.theme-inverse .form-check-input.invalid[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:hover,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:hover,.theme-inverse .form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check-input.invalid[disabled]:active,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:active,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:active,.theme-inverse .form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:active {background: #ffe6e6;border-color: #d94141;cursor: default;}.theme-inverse .form-check-input.invalid[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:checked,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:checked,.theme-inverse .form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}input[type=radio].form-check-input {border-radius: 8px;}input[type=radio].form-check-input:checked::after {background-color: #fff;border-radius: 3px;content: "";height: 6px;left: 5px;position: absolute;top: 5px;width: 6px;}input[type=checkbox].form-check-input {border-radius: 3px;}input[type=checkbox].form-check-input:indeterminate::after {border-bottom: 2px solid #fff;content: "";height: 4px;left: 26%;position: absolute;top: 20%;width: 7px;}input[type=checkbox].form-check-input:checked::after {border-bottom: 2px solid #fff;border-left: 2px solid #fff;content: "";height: 4px;left: 22%;position: absolute;top: 20%;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);width: 7px;}.form-check-inline {display: inline-block;}.form-check-inline + .form-check-inline {margin-left: 24px;margin-top: 0;}.col-form-label {font-size: 16px;line-height: 24px;margin-bottom: 0;padding-top: 8px;}.col-form-label-lg {font-size: 32px;line-height: 40px;padding-top: 4px;}.col-form-label-sm {font-size: 14px;line-height: 21px;padding-top: 5.5px;}.form-text {color: #555659;display: block;font-size: 14px;line-height: 21px;margin-top: 8px;}.form-text.invalid {color: #d94141;}.theme-inverse .form-text {color: #b1b1b3;}.theme-inverse .form-text.invalid {color: #f99;}.form-required::after {color: #d94141;content: "*";font-weight: normal;margin-left: 0.2em;}.chip.default-multi-select-input,.chip.small-multi-select-input {float: left;}.chip.default-multi-select-input {margin: 0.5px 4px 2px;}.chip.small-multi-select-input {margin: -1px 4px 1px;}.form-input-overlay {position: relative;}.form-input-overlay .overlay-front {left: 16px;position: absolute;top: 8px;}.form-input-overlay .overlay-front.overlay-sm {top: 4px;}.form-input-overlay .overlay-front.overlay-lg {top: 12px;}.form-input-overlay .overlay-back {position: absolute;right: 16px;top: 8px;}.form-input-overlay .overlay-back.overlay-sm {top: 4px;}.form-input-overlay .overlay-back.overlay-lg {top: 12px;}.form-input-overlay .form-control ~ .overlay-front,.form-input-overlay .form-control ~ .overlay-back {background-color: transparent;color: #222326;font-size: 16px;}.form-input-overlay .form-control:hover ~ .overlay-front,.form-input-overlay .form-control.hover ~ .overlay-front,.form-input-overlay .form-control:hover ~ .overlay-back,.form-input-overlay .form-control.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control:focus ~ .overlay-front,.form-input-overlay .form-control.focus ~ .overlay-front,.form-input-overlay .form-control:focus ~ .overlay-back,.form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control[disabled] ~ .overlay-front,.form-input-overlay .form-control.disabled ~ .overlay-front,.form-input-overlay .form-control[disabled] ~ .overlay-back,.form-input-overlay .form-control.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-input-overlay .form-control.form-control-transparent ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-inherit ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit ~ .overlay-back {color: inherit;font-size: inherit;font-weight: inherit;}.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .form-input-overlay .form-control ~ .overlay-front,.theme-inverse .form-input-overlay .form-control ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-back {color: #d7d7d9;}.form-input-overlay .form-control.form-control-outlined ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid ~ .overlay-front,.form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.hover ~ .overlay-front,.form-input-overlay .form-control.invalid:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:focus ~ .overlay-front,.form-input-overlay .form-control.invalid.focus ~ .overlay-front,.form-input-overlay .form-control.invalid:focus ~ .overlay-back,.form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .overlay-input-left-sm {padding-left: 32px;}.form-input-overlay .overlay-input-right-sm {padding-right: 32px;}.form-input-overlay .overlay-input-both-sm {padding-left: 32px;padding-right: 32px;}.form-input-overlay .overlay-input-left-md {padding-left: 56px;}.form-input-overlay .overlay-input-right-md {padding-right: 56px;}.form-input-overlay .overlay-input-both-md {padding-left: 56px;padding-right: 56px;}.form-input-overlay .overlay-input-left-lg {padding-left: 80px;}.form-input-overlay .overlay-input-right-lg {padding-right: 80px;}.form-input-overlay .overlay-input-both-lg {padding-left: 80px;padding-right: 80px;}.form-input-overlay .overlay-input-left-icon {padding-left: 40px;}.form-input-overlay .overlay-input-right-icon {padding-right: 40px;}.form-input-overlay .overlay-input-both-icon {padding-left: 40px;padding-right: 40px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl,.col,.col-auto,.col-grow,.col-1,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-10,.col-11,.col-12,.col-sm,.col-sm-auto,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-md,.col-md-auto,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-lg,.col-lg-auto,.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-xl,.col-xl-auto,.col-xl-1,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9,.col-xl-10,.col-xl-11,.col-xl-12 {min-height: 1px;padding-left: 8px;padding-right: 8px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl {margin-left: auto;margin-right: auto;width: 100%;}.container {max-width: 100%;}.container-sm {max-width: 100%;}.container-md {max-width: 100%;}.container-lg {max-width: 100%;}.container-xl {max-width: 100%;}.row {display: flex;flex-wrap: wrap;margin-left: -8px;margin-right: -8px;}.row.no-gutters {margin-left: 0;margin-right: 0;}.row.no-gutters > .col,.row.no-gutters > [class*="col-"] {padding-left: 0;padding-right: 0;}a.row {text-decoration: none;}.col {flex: 1 1 0%;min-width: 0;width: 100%;}.col-auto {flex: 0 0 auto;width: auto;}.col-grow {flex: 1 0 auto;}.col-icon {align-items: center;display: flex;flex: 0 0 24px;}.col-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-3 {flex: 0 0 25%;max-width: 25%;}.col-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-6 {flex: 0 0 50%;max-width: 50%;}.col-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-9 {flex: 0 0 75%;max-width: 75%;}.col-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-12 {flex: 0 0 100%;max-width: 100%;}.mo-identicon {background-color: #e3e4e6;border-radius: 3px;color: #555659;display: inline-block;font-size: 12px;height: 24px;line-height: 24px;overflow: hidden;position: relative;text-align: center;text-decoration: none;vertical-align: middle;width: 24px;}.mo-identicon img {height: 100%;width: 100%;}.mo-identicon-initials {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;color: #fff;height: 100%;text-shadow: 0 0 2px rgba(0,0,0,0.2);width: 100%;}.mo-identicon-placeholder {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;}.mo-identicon-placeholder .icon {color: #e3e4e6;height: 18px;width: 18px;}.mo-identicon-placeholder .icon,.momentum-body .mo-identicon-placeholder .icon {vertical-align: middle;}.mo-identicon-sm {font-size: 10px;height: 16px;line-height: 16px;width: 16px;}.mo-identicon-sm .mo-identicon-placeholder .icon {height: 12px;width: 12px;}.mo-identicon-lg {font-size: 14px;height: 32px;line-height: 32px;width: 32px;}.mo-identicon-lg .mo-identicon-placeholder .icon {height: 24px;width: 24px;}.mo-identicon-xl {font-size: 16px;height: 40px;line-height: 40px;width: 40px;}.mo-identicon-xl .mo-identicon-placeholder .icon {height: 30px;width: 30px;}.mo-identicon-initials-0 {background: -webkit-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -moz-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -o-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -ms-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: linear-gradient(-15deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;}.mo-identicon-initials-1 {background: -webkit-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -moz-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -o-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -ms-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: linear-gradient(-15deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;}.mo-identicon-initials-2 {background: -webkit-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -moz-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -o-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -ms-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: linear-gradient(-15deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;}.mo-identicon-initials-3 {background: -webkit-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -moz-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -o-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -ms-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: linear-gradient(-15deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;}.mo-identicon-initials-4 {background: -webkit-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -moz-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -o-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -ms-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: linear-gradient(-15deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;}.mo-identicon-initials-5 {background: -webkit-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -moz-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -o-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -ms-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: linear-gradient(-15deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;}.mo-identicon-initials-6 {background: -webkit-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -moz-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -o-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -ms-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: linear-gradient(-15deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;}.mo-identicon-initials-7 {background: -webkit-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -moz-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -o-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -ms-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: linear-gradient(-15deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;}.mo-identicon-initials-8 {background: -webkit-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -moz-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -o-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -ms-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: linear-gradient(-15deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;}.mo-identicon-initials-9 {background: -webkit-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -moz-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -o-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -ms-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: linear-gradient(-15deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;}.mo-identicon-initials-10 {background: -webkit-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -moz-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -o-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -ms-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: linear-gradient(-15deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;}.mo-identicon-initials-11 {background: -webkit-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -moz-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -o-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -ms-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: linear-gradient(-15deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;}.mo-identicon-initials-12 {background: -webkit-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -moz-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -o-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -ms-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: linear-gradient(-15deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;}.mo-identicon-initials-13 {background: -webkit-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -moz-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -o-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -ms-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: linear-gradient(-15deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;}.mo-identicon-initials-14 {background: -webkit-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -moz-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -o-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -ms-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: linear-gradient(-15deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;}.mo-identicon-initials-15 {background: -webkit-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -moz-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -o-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -ms-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: linear-gradient(-15deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;}.mo-identicon-initials-16 {background: -webkit-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -moz-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -o-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -ms-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: linear-gradient(-15deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;}.mo-identicon-initials-17 {background: -webkit-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -moz-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -o-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -ms-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: linear-gradient(-15deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;}.mo-identicon-initials-18 {background: -webkit-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -moz-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -o-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -ms-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: linear-gradient(-15deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;}.mo-identicon-initials-19 {background: -webkit-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -moz-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -o-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -ms-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: linear-gradient(-15deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;}.mo-identicon-initials-20 {background: -webkit-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -moz-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -o-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -ms-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: linear-gradient(-15deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;}.mo-identicon-initials-21 {background: -webkit-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -moz-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -o-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -ms-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: linear-gradient(-15deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;}.mo-identicon-initials-22 {background: -webkit-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -moz-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -o-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -ms-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: linear-gradient(-15deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;}.mo-identicon-initials-23 {background: -webkit-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -moz-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -o-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -ms-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: linear-gradient(-15deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;}.mo-identicon-initials-24 {background: -webkit-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -moz-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -o-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -ms-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: linear-gradient(-15deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;}.mo-identicon-initials-25 {background: -webkit-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -moz-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -o-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -ms-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: linear-gradient(-15deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;}.mo-identicon-initials-26 {background: -webkit-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -moz-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -o-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -ms-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: linear-gradient(-15deg, #515151, #515151 49%, #707070 51%, #707070) #515151;}.mo-identicon-initials-27 {background: -webkit-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -moz-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -o-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -ms-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: linear-gradient(-15deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;}.mo-identicon-initials-28 {background: -webkit-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -moz-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -o-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -ms-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: linear-gradient(-15deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;}.mo-identicon-initials-29 {background: -webkit-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -moz-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -o-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -ms-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: linear-gradient(-15deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;}.mo-identicon-initials-30 {background: -webkit-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -moz-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -o-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -ms-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: linear-gradient(-15deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;}.list-row {border-bottom: 1px solid #e3e4e6;border-top: 1px solid #e3e4e6;display: flex;flex-wrap: wrap;font-size: 16px;line-height: 24px;}.list-row + .list-row {margin-top: -1px;}.list-row > .col,.list-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.list-row.clickable:hover {background: #f0f1f2;cursor: pointer;}.list-row.clickable:active {background: #e3e4e6;}.list-row.clickable.selected {background: #f3faff;}.list-row.clickable.selected:hover {background: #e1f3ff;}.list-row.clickable.selected:active {background: #bfe5ff;}.list-row.hover,.list-row > .col.hover,.list-row > [class*="col-"].hover {background: #f0f1f2;}.list-row.active,.list-row > .col.active,.list-row > [class*="col-"].active {background: #e3e4e6;}.list-row.selected,.list-row > .col.selected,.list-row > [class*="col-"].selected {background: #f3faff;}.list-row.selected.hover,.list-row > .col.selected.hover,.list-row > [class*="col-"].selected.hover {background: #e1f3ff;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"] {text-decoration: none;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"],a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover,a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active,a.list-row:visited,.momentum-body a.list-row:visited,.list-row > a.col:visited,.list-row > a[class*="col-"]:visited,.momentum-body .momentum-body a.list-row:visited,.momentum-body .list-row > a.col:visited,.momentum-body .list-row > a[class*="col-"]:visited {color: #222326;}a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover {background: #f0f1f2;}a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active {background: #e3e4e6;}a.list-row.selected:active,.momentum-body a.list-row.selected:active,.list-row > a.col.selected:active,.list-row > a[class*="col-"].selected:active {background: #bfe5ff;}a.list-row.selected.selected:hover,.momentum-body a.list-row.selected.selected:hover,.list-row > a.col.selected.selected:hover,.list-row > a[class*="col-"].selected.selected:hover {background: #e1f3ff;}.list-row > .col-form-label {padding-top: 16px;}.list-row > .col-form-label-lg {padding-top: 12px;}.list-row > .col-form-label-sm {padding-top: 13.5px;}.list-row-head {border-top: 0;}.col-list-row-header {align-self: flex-end;color: #969799;font-size: 12px;line-height: 18px;}.menu-row {display: flex;flex-wrap: wrap;font-size: 14px;line-height: 21px;padding-left: 8px;padding-right: 8px;}.menu-row h3,.menu-row h4 {margin-bottom: 0;}.menu-row h3,.menu-row .momentum-body h3,.menu-row .text-h3,.menu-row .text-h3_5 {font-size: 20px;line-height: 24px;}.menu-row .font-size-h3 {font-size: 20px;}.menu-row .line-height-h3 {line-height: 24px;}.menu-row h4,.menu-row .momentum-body h4,.menu-row .text-h4 {font-size: 16px;line-height: 24px;}.menu-row .font-size-h4 {font-size: 16px;}.menu-row .line-height-h4 {line-height: 24px;}.menu-row > .col,.menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.menu-row.hover {background: #f0f1f2;}.menu-row.active {background: #e3e4e6;}.menu-row.selected {background: #e1f3ff;}.menu-row.selected.hover {background: #bfe5ff;}.menu-row.selected.active {background: #a6daff;}.menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.menu-row {text-decoration: none;}a.menu-row:hover,a.menu-row:active,a.menu-row:visited {color: inherit;}a.menu-row:hover {background: #f0f1f2;}a.menu-row:active {background: #e3e4e6;}a.menu-row.selected:hover {background: #bfe5ff;}a.menu-row.selected:active {background: #a6daff;}.menu-divider {border-top: 1px solid #e3e4e6;margin-bottom: 4px;margin-top: 3px;}.message {color: #222326;background-color: #f0f1f2;border-radius: 3px;padding-bottom: 8px;padding-left: 40px;padding-right: 32px;padding-top: 8px;position: relative;}.message > .icon {position: absolute;left: 16px;top: 11px;}.message > .icon path {fill: #969799;}.message > p,.momentum-body .message > p {margin-bottom: 0;}.message > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;line-height: 16px;height: 16px;position: absolute;right: 16px;text-align: center;top: 11px;width: 16px;}.message > .close:hover::after {color: #555659;}.message > .close:active::after {color: #222326;}.message > .message-buttons {clear: left;float: right;margin-top: -4px;margin-right: -16px;padding-left: 4px;}.message > .message-buttons > .button-link {margin-top: 4px;}.message.message-info {background-color: #e1f3ff;}.message.message-info > .icon path {fill: #0c92f3;}.message.message-warning {background-color: #fec;}.message.message-warning > .icon path {fill: #ff9000;}.message.message-positive {background-color: #d4f5c4;}.message.message-positive > .icon path {fill: #39bf71;}.message.message-negative {background-color: #ffe6e6;}.message.message-negative > .icon path {fill: #d94141;}.message.message-gray {background-color: #f0f1f2;}.message.message-blue {background-color: #e1f3ff;}.message.message-red {background-color: #ffe6e6;}.message.message-green {background-color: #d4f5c4;}.message.message-yellow {background-color: #fec;}.message.message-rose {background-color: #ffe0f0;}.message.message-violet {background-color: #f5e0ff;}.message.message-turquoise {background-color: #d9f7fa;}.message.message-striped-red {background: -webkit-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -moz-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -o-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -ms-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: repeating-linear-gradient(105deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);}.message.message-striped-blue {background: -webkit-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -moz-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -o-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -ms-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: repeating-linear-gradient(105deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);}.message.message-striped-green {background: -webkit-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -moz-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -o-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -ms-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: repeating-linear-gradient(105deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);}.message.message-inverse {background-color: #555659;color: #fff;}.message.message-inverse > .icon path {fill: #b1b1b3;}.message.message-inverse > .close::after {color: #969799;}.message.message-inverse > .close:hover::after {color: #b1b1b3;}.message.message-inverse > .close:active::after {color: #707173;}.message.message-compact {padding-top: 4px;padding-bottom: 4px;}.message.message-compact > .icon {top: 8.125px;}.message.message-compact > .close::after {top: 8.125px;}.message.message-compact > .message-buttons {margin-top: -5.5px;}.message.message-compact > .message-buttons > .button-link {margin-top: 5.5px;}.modal-backdrop {background-color: rgba(0,0,0,0.3);bottom: 0;display: none;left: 0;position: absolute;right: 0;top: 0;width: 100%;}.modal-backdrop.show {display: flex;}.modal {background: #fff;border-radius: 3px;display: flex;flex-direction: column;left: 0;margin: 0 auto;max-height: calc(100% - 96px);max-width: 640px;min-width: 480px;position: absolute;right: 0;top: 80px;}.modal-content {display: flex;flex-direction: column;height: 100%;overflow: auto;padding: 0 32px;}.modal-content.no-padding {padding: 0;}.modal-actions {align-items: flex-end;display: flex;flex: auto;justify-content: flex-end;padding: 24px 32px;}.modal-actions-distributed {align-items: flex-end;display: flex;flex: auto;justify-content: space-between;padding: 32px 32px;}.modal-navigation {height: auto;padding: 24px 32px 24px 32px;position: relative;}.modal-navigation.no-padding {padding: 0;}.modal-close {color: #555659;position: absolute;right: 16px;top: 16px;}.nav-link,.momentum-body .nav-link {color: $navLinkColor;font-size: $navLinkFontSize;text-decoration: none;}.nav-link:hover,.momentum-body .nav-link:hover {color: $navLinkHoverColor;text-decoration: underline;}.nav-link:active,.momentum-body .nav-link:active {color: $navLinkActiveColor;text-decoration: underline;}.nav-link > .icon {margin-left: 4px;margin-right: 4px;}.nav-link > .icon:first-child {margin-left: 0;}.nav-link > .icon:last-child {margin-right: 0;}.progress-bar .bar,.progress-bar .bar-interactive {align-items: center;border-radius: 3px;display: flex;height: 16px;justify-content: center;-webkit-transition: width 350ms ease-out;-moz-transition: width 350ms ease-out;-o-transition: width 350ms ease-out;-ms-transition: width 350ms ease-out;transition: width 350ms ease-out;}.progress-bar {align-items: center;border-radius: 3px;display: flex;}.progress-bar .bar-container {align-content: center;align-items: center;display: flex;padding: 0;width: 100%;justify-content: space-between;position: relative;}.progress-bar .bar-interactive:hover {cursor: pointer;}.progress-bar .bar-progress-text {display: flex;font-size: 12px;line-height: 12px;position: absolute;padding: 0 0 0 4px;}.progress-bar .bar-progress-text-inverted {position: static;}.progress-bar .bar-title {margin-right: 8px;text-transform: capitalize;}.score {background-color: #555659;border-radius: 3px;color: #fff;display: inline-block;font-size: 16px;height: 24px;line-height: 24px;overflow: hidden;text-align: center;vertical-align: middle;width: 24px;}.score .icon {height: 16px;width: 16px;}.score .mo-identicon {border-radius: 0;vertical-align: unset;}.score.score-worst {background-color: #555659;color: #d7d7d9;}.score.score-bad {background-color: #555659;color: #b1b1b3;}.score.score-good {background-color: #555659;color: #61d086;}.score.score-best {background-color: #555659;color: #8ae58a;}.score.score-unknown {background-color: #e3e4e6;color: #555659;}.score.score-sm {font-size: 12px;height: 16px;line-height: 16px;width: 16px;}.score.score-sm .icon {height: 12px;width: 12px;}.score.score-lg {font-size: 20px;height: 32px;line-height: 32px;width: 32px;}.score.score-lg .icon {height: 20px;width: 20px;}.score.score-xl {font-size: 24px;height: 40px;line-height: 40px;width: 40px;}.score.score-xl .icon {height: 24px;width: 24px;}.score-group {display: inline-block;}.score-group .score {border-radius: 0;}.score-group .score:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.score-group .score:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.arrow {position: relative;}.arrow .line,.arrow .line::after {height: 40px;}.arrow .line {display: block;text-align: center;}.arrow .line::after {position: absolute;background: #b1b1b3;content: ' ';margin-left: -1px;width: 2px;}.arrow .arrow-overlay {position: absolute;top: 50%;left: 50%;-webkit-transform: translate(-50%, -50%);-moz-transform: translate(-50%, -50%);-o-transform: translate(-50%, -50%);-ms-transform: translate(-50%, -50%);transform: translate(-50%, -50%);}.arrow.direction-down .arrow-head,.arrow.direction-up .arrow-head {width: 10px;height: 10px;position: absolute;left: calc(50% - 5px);}.arrow.direction-down .arrow-head::after,.arrow.direction-up .arrow-head::after {display: block;position: absolute;content: '';height: 10px;margin: 0;padding: 0;width: 10px;-webkit-box-shadow: inset -2px 2px 0 0 #b1b1b3;box-shadow: inset -2px 2px 0 0 #b1b1b3;}.arrow.direction-up .arrow-head {top: 0;}.arrow.direction-up .arrow-head::after {-moz-transform: rotate(-45deg);-ms-transform: rotate(-45deg);-o-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.arrow.direction-down .arrow-head {bottom: 0;}.arrow.direction-down .arrow-head::after {-moz-transform: rotate(135deg);-ms-transform: rotate(135deg);-o-transform: rotate(135deg);-webkit-transform: rotate(135deg);-webkit-transform: rotate(135deg);-moz-transform: rotate(135deg);-o-transform: rotate(135deg);-ms-transform: rotate(135deg);transform: rotate(135deg);}.arrow.length-long .line,.arrow.length-long .line::after {height: 72px;}.animation-shimmer {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -moz-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -o-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -ms-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: linear-gradient(to right, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-size: 1000px 100%;}.animation-shimmer-inverse {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -moz-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -o-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -ms-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: linear-gradient(to right, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-size: 1000px 100%;}@-moz-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-webkit-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-o-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}.sidebar-menu {background-color: #f9f9f9;height: 100%;overflow-y: auto;width: 304px;}.sidebar-menu-width {width: 304px;}.sidebar-menu-row {color: #969799;display: flex;flex-wrap: wrap;padding-left: 16px;padding-right: 16px;}.sidebar-menu-row h4,.sidebar-menu-row h3 {margin-bottom: 0;}.sidebar-menu-row > .col,.sidebar-menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.sidebar-menu-row.hover {background: #fff;}.sidebar-menu-row.active {background: #e1f3ff;}.sidebar-menu-row.selected {color: #555659;background: #fff;border-left: 4px solid #0c92f3;padding-left: 12px;}.sidebar-menu-row.selected.hover {background: #f3faff;}.sidebar-menu-row.selected.active {background: #e1f3ff;}.sidebar-menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.sidebar-menu-row {color: #969799;text-decoration: none;}a.sidebar-menu-row:hover,a.sidebar-menu-row:active,a.sidebar-menu-row:visited {color: inherit;}a.sidebar-menu-row:hover {background: #fff;}a.sidebar-menu-row.selected {color: #555659;}a.sidebar-menu-row.selected:hover {background: #f3faff;}a.sidebar-menu-row.selected:active {background: #e1f3ff;}.sidebar-button-menu {width: 64px;height: 100%;overflow-y: auto;background-color: #f9f9f9;display: flex;flex-direction: column;align-items: center;}.sidebar-button-menu .sidebar-button-menu-row {margin-bottom: 8px;}.sidebar-button-menu .sidebar-button-menu-row .button {border: none;background-color: unset;background-image: unset;}.sidebar-button-menu .sidebar-button-menu-row:hover {margin-bottom: 6px;}.sidebar-button-menu .sidebar-button-menu-row:hover .button {-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);border-bottom: 2px solid #0c92f3;}.sidebar-button-menu .sidebar-button-menu-row.selected .button {background-color: #fff;-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);}.tab-links,.tab-links-border-bottom {display: flex;}.tab-link {border-bottom: 4px solid transparent;color: #969799;cursor: pointer;margin-left: 8px;margin-right: 8px;padding-bottom: 8px;}.tab-link:first-child {margin-left: 0;}.tab-link:last-child {margin-right: 0;}.tab-link,.momentum-body a.tab-link {text-decoration: none;color: #969799;}.tab-link:hover,.momentum-body a.tab-link:hover,.tab-link.hover,.momentum-body a.tab-link.hover {color: #707173;border-bottom-color: #b1b1b3;}.tab-link:active,.momentum-body a.tab-link:active {border-bottom-color: #969799;}.tab-link.selected,.momentum-body a.tab-link.selected {border-bottom-color: #0c92f3;color: #555659;}.tab-links-border-bottom {border-bottom: 1px solid #e3e4e6;}.tab-links-border-bottom .tab-link {margin-bottom: -1px;margin-left: 0;margin-right: 0;padding-left: 8px;padding-right: 8px;}.tabs {border-bottom: 1px solid #e3e4e6;display: flex;}.tab {border-color: #e3e4e6;border-style: solid;border-top-left-radius: 3px;border-top-right-radius: 3px;border-width: 1px;cursor: pointer;margin-bottom: -1px;margin-left: 8px;margin-right: 8px;padding: 8px 16px;text-align: center;}.tab:first-child {margin-left: 0;}.tab:last-child {margin-right: 0;}.tab,.momentum-body a.tab {background-color: #fff;color: #969799;text-decoration: none;}.tab:hover,.momentum-body a.tab:hover,.tab.hover,.momentum-body a.tab.hover {color: #707173;}.tab.selected,.momentum-body a.tab.selected {border-bottom-color: #fff;color: #555659;}.toast {-webkit-animation: toastFadeIn 0.3s ease-out;-moz-animation: toastFadeIn 0.3s ease-out;-o-animation: toastFadeIn 0.3s ease-out;-ms-animation: toastFadeIn 0.3s ease-out;animation: toastFadeIn 0.3s ease-out;border-left: 4px solid #969799;border-radius: 3px;display: inline-block;max-width: 480px;padding-bottom: 8px;padding-left: 48px;padding-right: 48px;padding-top: 8px;position: relative;}.toast > .icon {color: #555659;left: 16px;position: absolute;top: 12px;}.toast > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;height: 16px;line-height: 16px;position: absolute;right: 16px;text-align: center;top: 12px;width: 16px;}.toast > .close:hover::after {color: #555659;}.toast > .close:active::after {color: #222326;}.toast > .toast-buttons {margin-bottom: 8px;margin-top: 16px;}.toast.toast-info {border-left-color: #0c92f3;}.toast.toast-warning {border-left-color: #ffa60d;}.toast.toast-positive {border-left-color: #39bf71;}.toast.toast-negative {border-left-color: #d94141;}.toast.theme-inverse > .icon {color: #969799;}.toast.theme-inverse > .close::after {color: #969799;}.toast.theme-inverse > .close:hover::after {color: #b1b1b3;}.toast.theme-inverse > .close:active::after {color: #707173;}@-moz-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-webkit-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-o-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}.toggle {color: rgba(85,86,89,0.7);background-color: rgba(177,177,179,0.4);border-radius: 11px;border-width: 0;cursor: pointer;display: inline-block;height: 22px;margin: 1px 8px;padding: 0;position: relative;-webkit-transition: background-color 0.15s ease-in;-moz-transition: background-color 0.15s ease-in;-o-transition: background-color 0.15s ease-in;-ms-transition: background-color 0.15s ease-in;transition: background-color 0.15s ease-in;vertical-align: top;width: 40px;}.toggle:hover,.toggle.hover {background-color: rgba(177,177,179,0.6);}.toggle:active,.toggle.active {background-color: #b1b1b3;}.toggle:focus,.toggle.focus {outline: none;}.toggle[disabled],.toggle.disabled {background-color: rgba(177,177,179,0.4);}.toggle:first-child {margin-left: 0;}.toggle:last-child {margin-right: 0;}.toggle::after {background-color: #fff;border-radius: 8px;content: " ";display: block;height: 16px;left: 3px;top: 3px;position: absolute;-webkit-transition: left 0.15s linear;-moz-transition: left 0.15s linear;-o-transition: left 0.15s linear;-ms-transition: left 0.15s linear;transition: left 0.15s linear;width: 16px;}.toggle .icon,.momentum-body .toggle .icon {position: absolute;height: 12px;width: 12px;left: 23px;top: 5px;}.toggle.selected {color: rgba(255,255,255,0.7);background-color: #0c92f3;}.toggle.selected:hover,.toggle.selected.hover {background-color: #007fd9;}.toggle.selected:active,.toggle.selected.active {background-color: #0068b3;}.toggle.selected:focus,.toggle.selected.focus {outline: none;}.toggle.selected[disabled],.toggle.selected.disabled {background-color: #0c92f3;}.toggle.selected::after {left: 21px;}.toggle.selected .icon,.momentum-body .toggle.selected .icon {left: 5px;}.toggle.disabled {cursor: default;pointer-events: none;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.toggle.toggle-yellow.selected {color: rgba(255,255,255,0.7);background-color: #fb3;}.toggle.toggle-yellow.selected:hover,.toggle.toggle-yellow.selected.hover {background-color: #ffa60d;}.toggle.toggle-yellow.selected:active,.toggle.toggle-yellow.selected.active {background-color: #ff9000;}.toggle.toggle-yellow.selected:focus,.toggle.toggle-yellow.selected.focus {outline: none;}.toggle.toggle-yellow.selected[disabled],.toggle.toggle-yellow.selected.disabled {background-color: #fb3;}.toggle-lg {border-radius: 14px;height: 28px;width: 48px;margin-top: 4px;margin-bottom: 4px;}.toggle-lg::after {border-radius: 10px;height: 20px;left: 4px;top: 4px;width: 20px;}.toggle-lg .icon,.momentum-body .toggle-lg .icon {height: 16px;width: 16px;left: 26px;top: 6px;}.toggle-lg.selected::after {left: 24px;}.toggle-lg.selected .icon,.momentum-body .toggle-lg.selected .icon {left: 6px;}.toggle-sm {border-radius: 8px;height: 16px;width: 32px;margin-top: 2.5px;margin-bottom: 2.5px;}.toggle-sm::after {border-radius: 6px;height: 12px;left: 2px;top: 2px;width: 12px;}.toggle-sm .icon,.momentum-body .toggle-sm .icon {height: 9px;width: 9px;left: 19.5px;top: 3.5px;}.toggle-sm.selected::after {left: 18px;}.toggle-sm.selected .icon,.momentum-body .toggle-sm.selected .icon {left: 3.5px;}.text-h1 {font-size: 40px;font-weight: bold;line-height: 48px;}.text-h2 {font-size: 32px;font-weight: bold;line-height: 40px;}.text-h3 {font-size: 24px;font-weight: bold;line-height: 36px;}.text-h3_5 {font-size: 20px;font-weight: bold;line-height: 24px;}.text-h4 {font-size: 16px;font-weight: bold;line-height: 24px;}.text-h5 {font-size: 14px;font-weight: bold;line-height: 21px;}.text-base {font-size: 16px;font-weight: normal;line-height: 24px;}.text-small {font-size: 14px;font-weight: normal;line-height: 21px;}.text-caption {font-size: 12px;font-weight: normal;line-height: 18px;}.font-size-h1 {font-size: 40px;}.font-size-h2 {font-size: 32px;}.font-size-h3 {font-size: 24px;}.font-size-h3_5 {font-size: 20px;}.font-size-h4 {font-size: 16px;}.font-size-base {font-size: 16px;}.font-size-small {font-size: 14px;}.font-size-caption {font-size: 12px;}.line-height-h1 {line-height: 48px;}.line-height-h2 {line-height: 40px;}.line-height-h3 {line-height: 36px;}.line-height-h3_5 {line-height: 24px;}.line-height-h4 {line-height: 24px;}.line-height-base {line-height: 24px;}.line-height-small {line-height: 21px;}.line-height-caption {line-height: 18px;}.text-color-heading {color: #222326;}.text-color-body {color: #222326;}.text-muted {color: #555659;}.text-positive {color: #19a654;}.text-muted-positive {color: #61d086;}.text-negative {color: #d94141;}.text-muted-negative {color: #f99;}.upload {align-items: center;background-color: #fff;border: 2px #d7d7d9;border-style: dashed;color: #969799;cursor: pointer;display: flex;flex-direction: column;justify-content: center;padding: 8px;position: relative;}.upload:hover,.upload.hover {background-color: #f3faff;}.upload .upload-file {cursor: pointer;height: 100%;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);position: absolute;width: 100%;}.upload > .remove::after {align-items: center;background-color: #555659;border-radius: 50%;color: #fff;content: "✕";display: flex;font-size: 12px;height: 18px;justify-content: center;line-height: 12px;position: absolute;right: 12px;top: 12px;width: 18px;}.upload > .remove:hover::after {background-color: #707173;}.upload > .remove:active::after {background-color: #3b3d3f;}.upload-dragging {background-color: #f3faff;}.upload-no-border {border: 0;}.upload-dropping {background-color: #f3faff;border: 2px #0c92f3;border-style: dashed;}.upload-error {border: 2px #d94141;border-style: dashed;}.upload-preview {display: inline-block;line-height: 0;padding: 0;}.upload-icon {color: #d7d7d9;}.upload-icon.icon {margin-left: 0;margin-right: 0;}.animation-rotate-infinite {-webkit-animation: rotate-infinite infinite;-moz-animation: rotate-infinite infinite;-o-animation: rotate-infinite infinite;-ms-animation: rotate-infinite infinite;animation: rotate-infinite infinite;}.animation-fade-in {-webkit-animation: fade-in 1 ease both;-moz-animation: fade-in 1 ease both;-o-animation: fade-in 1 ease both;-ms-animation: fade-in 1 ease both;animation: fade-in 1 ease both;}.animation-fade-out {-webkit-animation: fade-out 1 ease both;-moz-animation: fade-out 1 ease both;-o-animation: fade-out 1 ease both;-ms-animation: fade-out 1 ease both;animation: fade-out 1 ease both;}.animation-ease {-webkit-animation-timing-function: ease;-moz-animation-timing-function: ease;-o-animation-timing-function: ease;-ms-animation-timing-function: ease;animation-timing-function: ease;}.animation-linear {-webkit-animation-timing-function: linear;-moz-animation-timing-function: linear;-o-animation-timing-function: linear;-ms-animation-timing-function: linear;animation-timing-function: linear;}.animation-duration-100ms {-webkit-animation-duration: 100ms;-moz-animation-duration: 100ms;-o-animation-duration: 100ms;-ms-animation-duration: 100ms;animation-duration: 100ms;}.animation-duration-200ms {-webkit-animation-duration: 200ms;-moz-animation-duration: 200ms;-o-animation-duration: 200ms;-ms-animation-duration: 200ms;animation-duration: 200ms;}.animation-duration-300ms {-webkit-animation-duration: 300ms;-moz-animation-duration: 300ms;-o-animation-duration: 300ms;-ms-animation-duration: 300ms;animation-duration: 300ms;}.animation-duration-400ms {-webkit-animation-duration: 400ms;-moz-animation-duration: 400ms;-o-animation-duration: 400ms;-ms-animation-duration: 400ms;animation-duration: 400ms;}.animation-duration-500ms {-webkit-animation-duration: 500ms;-moz-animation-duration: 500ms;-o-animation-duration: 500ms;-ms-animation-duration: 500ms;animation-duration: 500ms;}.animation-duration-1000ms {-webkit-animation-duration: 1000ms;-moz-animation-duration: 1000ms;-o-animation-duration: 1000ms;-ms-animation-duration: 1000ms;animation-duration: 1000ms;}.animation-duration-2000ms {-webkit-animation-duration: 2000ms;-moz-animation-duration: 2000ms;-o-animation-duration: 2000ms;-ms-animation-duration: 2000ms;animation-duration: 2000ms;}.animation-count-1 {-webkit-animation-iteration-count: 1;-moz-animation-iteration-count: 1;-o-animation-iteration-count: 1;-ms-animation-iteration-count: 1;animation-iteration-count: 1;}.animation-count-infinite {-webkit-animation-iteration-count: infinite;-moz-animation-iteration-count: infinite;-o-animation-iteration-count: infinite;-ms-animation-iteration-count: infinite;animation-iteration-count: infinite;}.animation-direction-normal {-webkit-animation-direction: normal;-moz-animation-direction: normal;-o-animation-direction: normal;-ms-animation-direction: normal;animation-direction: normal;}.animation-direction-reverse {-webkit-animation-direction: reverse;-moz-animation-direction: reverse;-o-animation-direction: reverse;-ms-animation-direction: reverse;animation-direction: reverse;}@-moz-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-moz-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}.border {border: 1px solid #e3e4e6;}.border-top {border-top: 1px solid #e3e4e6;}.border-right {border-right: 1px solid #e3e4e6;}.border-bottom {border-bottom: 1px solid #e3e4e6;}.border-left {border-left: 1px solid #e3e4e6;}.border-width-1 {border-width: 4px;}.border-width-2 {border-width: 8px;}.border-width-3 {border-width: 12px;}.border-width-4 {border-width: 16px;}.border-width-5 {border-width: 20px;}.border-width-6 {border-width: 24px;}.border-width-7 {border-width: 28px;}.border-width-8 {border-width: 32px;}.border-width-9 {border-width: 36px;}.border-width-10 {border-width: 40px;}.border-width-11 {border-width: 44px;}.border-width-12 {border-width: 48px;}.border-width-13 {border-width: 52px;}.border-width-14 {border-width: 56px;}.border-width-15 {border-width: 60px;}.border-width-16 {border-width: 64px;}.border-width-17 {border-width: 68px;}.border-width-18 {border-width: 72px;}.border-width-19 {border-width: 76px;}.border-width-20 {border-width: 80px;}.border-width-21 {border-width: 84px;}.border-width-22 {border-width: 88px;}.border-width-23 {border-width: 92px;}.border-width-24 {border-width: 96px;}.border-width-25 {border-width: 100px;}.border-width-26 {border-width: 104px;}.border-width-27 {border-width: 108px;}.border-width-28 {border-width: 112px;}.border-width-29 {border-width: 116px;}.border-width-30 {border-width: 120px;}.border-none {border: 0;}.border-top-none {border-top: 0;}.border-right-none {border-right: 0;}.border-bottom-none {border-bottom: 0;}.border-left-none {border-left: 0;}.rounded {border-radius: 3px;}.circle {border-radius: 50%;}.rounded-top {border-radius: 3px 3px 0 0;}.rounded-right {border-radius: 0 3px 3px 0;}.rounded-bottom {border-radius: 0 0 3px 3px;}.rounded-left {border-radius: 3px 0 0 3px;}.not-rounded {border-radius: 0;}.dashed {border-style: dashed;}.text-white {color: #fff;}.bg-white {background-color: #fff;}.border-white {border-color: #fff;}.text-black {color: #000;}.bg-black {background-color: #000;}.border-black {border-color: #000;}.text-ghost {color: #f4f7fa;}.bg-ghost {background-color: #f4f7fa;}.border-ghost {border-color: #f4f7fa;}.text-gray {color: #969799;}.bg-gray {background-color: #969799;}.border-gray {border-color: #969799;}.text-blue {color: #0c92f3;}.bg-blue {background-color: #0c92f3;}.border-blue {border-color: #0c92f3;}.text-red {color: #d94141;}.bg-red {background-color: #d94141;}.border-red {border-color: #d94141;}.text-green {color: #39bf71;}.bg-green {background-color: #39bf71;}.border-green {border-color: #39bf71;}.text-yellow {color: #ffa60d;}.bg-yellow {background-color: #ffa60d;}.border-yellow {border-color: #ffa60d;}.text-rose {color: #dc4c7d;}.bg-rose {background-color: #dc4c7d;}.border-rose {border-color: #dc4c7d;}.text-violet {color: #a452cc;}.bg-violet {background-color: #a452cc;}.border-violet {border-color: #a452cc;}.text-turquoise {color: #1cadba;}.bg-turquoise {background-color: #1cadba;}.border-turquoise {border-color: #1cadba;}.text-gray-50 {color: #f9f9f9;}.bg-gray-50 {background-color: #f9f9f9;}.border-gray-50 {border-color: #f9f9f9;}.text-gray-100 {color: #f0f1f2;}.bg-gray-100 {background-color: #f0f1f2;}.border-gray-100 {border-color: #f0f1f2;}.text-gray-200 {color: #e3e4e6;}.bg-gray-200 {background-color: #e3e4e6;}.border-gray-200 {border-color: #e3e4e6;}.text-gray-300 {color: #d7d7d9;}.bg-gray-300 {background-color: #d7d7d9;}.border-gray-300 {border-color: #d7d7d9;}.text-gray-400 {color: #b1b1b3;}.bg-gray-400 {background-color: #b1b1b3;}.border-gray-400 {border-color: #b1b1b3;}.text-gray-500 {color: #969799;}.bg-gray-500 {background-color: #969799;}.border-gray-500 {border-color: #969799;}.text-gray-600 {color: #707173;}.bg-gray-600 {background-color: #707173;}.border-gray-600 {border-color: #707173;}.text-gray-700 {color: #555659;}.bg-gray-700 {background-color: #555659;}.border-gray-700 {border-color: #555659;}.text-gray-800 {color: #3b3d3f;}.bg-gray-800 {background-color: #3b3d3f;}.border-gray-800 {border-color: #3b3d3f;}.text-gray-900 {color: #222326;}.bg-gray-900 {background-color: #222326;}.border-gray-900 {border-color: #222326;}.text-blue-50 {color: #f3faff;}.bg-blue-50 {background-color: #f3faff;}.border-blue-50 {border-color: #f3faff;}.text-red-50 {color: #fff7f7;}.bg-red-50 {background-color: #fff7f7;}.border-red-50 {border-color: #fff7f7;}.text-green-50 {color: #e1fae5;}.bg-green-50 {background-color: #e1fae5;}.border-green-50 {border-color: #e1fae5;}.text-yellow-50 {color: #fff6e5;}.bg-yellow-50 {background-color: #fff6e5;}.border-yellow-50 {border-color: #fff6e5;}.text-blue-100 {color: #e1f3ff;}.bg-blue-100 {background-color: #e1f3ff;}.border-blue-100 {border-color: #e1f3ff;}.text-red-100 {color: #ffe6e6;}.bg-red-100 {background-color: #ffe6e6;}.border-red-100 {border-color: #ffe6e6;}.text-green-100 {color: #d4f5c4;}.bg-green-100 {background-color: #d4f5c4;}.border-green-100 {border-color: #d4f5c4;}.text-yellow-100 {color: #fec;}.bg-yellow-100 {background-color: #fec;}.border-yellow-100 {border-color: #fec;}.text-blue-200 {color: #bfe5ff;}.bg-blue-200 {background-color: #bfe5ff;}.border-blue-200 {border-color: #bfe5ff;}.text-red-200 {color: #ffbfbf;}.bg-red-200 {background-color: #ffbfbf;}.border-red-200 {border-color: #ffbfbf;}.text-green-200 {color: #b4f0a8;}.bg-green-200 {background-color: #b4f0a8;}.border-green-200 {border-color: #b4f0a8;}.text-yellow-200 {color: #ffe5b2;}.bg-yellow-200 {background-color: #ffe5b2;}.border-yellow-200 {border-color: #ffe5b2;}.text-blue-300 {color: #a6daff;}.bg-blue-300 {background-color: #a6daff;}.border-blue-300 {border-color: #a6daff;}.text-red-300 {color: #f99;}.bg-red-300 {background-color: #f99;}.border-red-300 {border-color: #f99;}.text-green-300 {color: #8ae58a;}.bg-green-300 {background-color: #8ae58a;}.border-green-300 {border-color: #8ae58a;}.text-yellow-300 {color: #ffdf88;}.bg-yellow-300 {background-color: #ffdf88;}.border-yellow-300 {border-color: #ffdf88;}.text-blue-400 {color: #4cb5ff;}.bg-blue-400 {background-color: #4cb5ff;}.border-blue-400 {border-color: #4cb5ff;}.text-red-400 {color: #f26161;}.bg-red-400 {background-color: #f26161;}.border-red-400 {border-color: #f26161;}.text-green-400 {color: #61d086;}.bg-green-400 {background-color: #61d086;}.border-green-400 {border-color: #61d086;}.text-yellow-400 {color: #fb3;}.bg-yellow-400 {background-color: #fb3;}.border-yellow-400 {border-color: #fb3;}.text-blue-500 {color: #0c92f3;}.bg-blue-500 {background-color: #0c92f3;}.border-blue-500 {border-color: #0c92f3;}.text-red-500 {color: #d94141;}.bg-red-500 {background-color: #d94141;}.border-red-500 {border-color: #d94141;}.text-green-500 {color: #39bf71;}.bg-green-500 {background-color: #39bf71;}.border-green-500 {border-color: #39bf71;}.text-yellow-500 {color: #ffa60d;}.bg-yellow-500 {background-color: #ffa60d;}.border-yellow-500 {border-color: #ffa60d;}.text-blue-600 {color: #007fd9;}.bg-blue-600 {background-color: #007fd9;}.border-blue-600 {border-color: #007fd9;}.text-red-600 {color: #bf3939;}.bg-red-600 {background-color: #bf3939;}.border-red-600 {border-color: #bf3939;}.text-green-600 {color: #19a654;}.bg-green-600 {background-color: #19a654;}.border-green-600 {border-color: #19a654;}.text-yellow-600 {color: #ff9000;}.bg-yellow-600 {background-color: #ff9000;}.border-yellow-600 {border-color: #ff9000;}.text-blue-700 {color: #0068b3;}.bg-blue-700 {background-color: #0068b3;}.border-blue-700 {border-color: #0068b3;}.text-red-700 {color: #a62929;}.bg-red-700 {background-color: #a62929;}.border-red-700 {border-color: #a62929;}.text-green-700 {color: #0e8c42;}.bg-green-700 {background-color: #0e8c42;}.border-green-700 {border-color: #0e8c42;}.text-yellow-700 {color: #e67600;}.bg-yellow-700 {background-color: #e67600;}.border-yellow-700 {border-color: #e67600;}.text-turquoise-50 {color: #f0fbfc;}.bg-turquoise-50 {background-color: #f0fbfc;}.border-turquoise-50 {border-color: #f0fbfc;}.text-turquoise-100 {color: #d9f7fa;}.bg-turquoise-100 {background-color: #d9f7fa;}.border-turquoise-100 {border-color: #d9f7fa;}.text-turquoise-200 {color: #b8f0f5;}.bg-turquoise-200 {background-color: #b8f0f5;}.border-turquoise-200 {border-color: #b8f0f5;}.text-turquoise-300 {color: #91eaf2;}.bg-turquoise-300 {background-color: #91eaf2;}.border-turquoise-300 {border-color: #91eaf2;}.text-turquoise-400 {color: #33c0cd;}.bg-turquoise-400 {background-color: #33c0cd;}.border-turquoise-400 {border-color: #33c0cd;}.text-turquoise-500 {color: #1cadba;}.bg-turquoise-500 {background-color: #1cadba;}.border-turquoise-500 {border-color: #1cadba;}.text-turquoise-600 {color: #0097a6;}.bg-turquoise-600 {background-color: #0097a6;}.border-turquoise-600 {border-color: #0097a6;}.text-turquoise-700 {color: #007580;}.bg-turquoise-700 {background-color: #007580;}.border-turquoise-700 {border-color: #007580;}.text-turquoise-800 {color: #005e66;}.bg-turquoise-800 {background-color: #005e66;}.border-turquoise-800 {border-color: #005e66;}.text-turquoise-900 {color: #00464d;}.bg-turquoise-900 {background-color: #00464d;}.border-turquoise-900 {border-color: #00464d;}.text-violet-50 {color: #f8ebff;}.bg-violet-50 {background-color: #f8ebff;}.border-violet-50 {border-color: #f8ebff;}.text-violet-100 {color: #f5e0ff;}.bg-violet-100 {background-color: #f5e0ff;}.border-violet-100 {border-color: #f5e0ff;}.text-violet-200 {color: #ebc4ff;}.bg-violet-200 {background-color: #ebc4ff;}.border-violet-200 {border-color: #ebc4ff;}.text-violet-300 {color: #dea2fc;}.bg-violet-300 {background-color: #dea2fc;}.border-violet-300 {border-color: #dea2fc;}.text-violet-400 {color: #bf75e3;}.bg-violet-400 {background-color: #bf75e3;}.border-violet-400 {border-color: #bf75e3;}.text-violet-500 {color: #a452cc;}.bg-violet-500 {background-color: #a452cc;}.border-violet-500 {border-color: #a452cc;}.text-violet-600 {color: #9c2bd4;}.bg-violet-600 {background-color: #9c2bd4;}.border-violet-600 {border-color: #9c2bd4;}.text-violet-700 {color: #801bb2;}.bg-violet-700 {background-color: #801bb2;}.border-violet-700 {border-color: #801bb2;}.text-violet-800 {color: #620e8c;}.bg-violet-800 {background-color: #620e8c;}.border-violet-800 {border-color: #620e8c;}.text-violet-900 {color: #521173;}.bg-violet-900 {background-color: #521173;}.border-violet-900 {border-color: #521173;}.bg-transparent {background: transparent;}.cursor-pointer {cursor: pointer;}.cursor-text {cursor: text;}.cursor-default {cursor: default;}.cursor-inherit {cursor: inherit;}.flex {display: flex;}.flex-column {flex-direction: column;}.flex-row {flex-direction: row;}.flex-row-reverse {flex-direction: row-reverse;}.flex-column-reverse {flex-direction: column-reverse;}.flex-wrap {flex-wrap: wrap;}.flex-nowrap {flex-wrap: nowrap;}.flex-grow {flex: 1 0 auto;}.flex-shrink {flex: 0 1 auto;}.flex-auto {flex: 1 1 auto;min-height: 0;min-width: 0;}.flex-none {flex: none;}.items-start {align-items: flex-start;}.items-end {align-items: flex-end;}.items-center {align-items: center;}.items-baseline {align-items: baseline;}.items-stretch {align-items: stretch;}.self-start {align-self: flex-start;}.self-end {align-self: flex-end;}.self-center {align-self: center;}.self-baseline {align-self: baseline;}.self-stretch {align-self: stretch;}.justify-start {justify-content: flex-start;}.justify-end {justify-content: flex-end;}.justify-center {justify-content: center;}.justify-between {justify-content: space-between;}.justify-around {justify-content: space-around;}.justify-evenly {justify-content: space-evenly;}.content-start {align-content: flex-start;}.content-end {align-content: flex-end;}.content-center {align-content: center;}.content-between {align-content: space-between;}.content-around {align-content: space-around;}.content-stretch {align-content: stretch;}.order-0 {order: 0;}.order-1 {order: 1;}.order-2 {order: 2;}.order-3 {order: 3;}.order-last {order: 99999;}.icon-size-base {height: 16px;width: 16px;}.icon-size-caption,.momentum-body .icon-size-caption {height: 12px;width: 12px;}.identicon-size,.momentum-body .identicon-size {height: 24px;width: 24px;line-height: 24px;}.display-none {display: none;}.display-inline,.inline {display: inline;}.display-block,.block {display: block;}.display-inline-block,.inline-block {display: inline-block;}.display-table,.table {display: table;}.display-table-cell,.table-cell {display: table-cell;}.visibility-hidden {visibility: hidden;}.overflow-hidden {overflow: hidden;}.overflow-scroll {overflow: scroll;}.overflow-auto {overflow: auto;}.overflow-visible {overflow: visible;}.float-left {float: left;}.float-right {float: right;}.fit-width {max-width: 100%;}.bulleted-list {margin-left: 16px;list-style-type: circle;}.bulleted-list li {margin-bottom: 8px;}.m0 {margin: 0;}.mt0 {margin-top: 0;}.mr0 {margin-right: 0;}.mb0 {margin-bottom: 0;}.ml0 {margin-left: 0;}.mx0 {margin-left: 0;margin-right: 0;}.my0 {margin-bottom: 0;margin-top: 0;}.m0_5 {margin: 4px;}.mt0_5 {margin-top: 4px;}.mr0_5 {margin-right: 4px;}.mb0_5 {margin-bottom: 4px;}.ml0_5 {margin-left: 4px;}.mx0_5 {margin-left: 4px;margin-right: 4px;}.my0_5 {margin-bottom: 4px;margin-top: 4px;}.m1 {margin: 8px;}.mt1 {margin-top: 8px;}.mr1 {margin-right: 8px;}.mb1 {margin-bottom: 8px;}.ml1 {margin-left: 8px;}.mx1 {margin-left: 8px;margin-right: 8px;}.my1 {margin-bottom: 8px;margin-top: 8px;}.m1_5 {margin: 12px;}.mt1_5 {margin-top: 12px;}.mr1_5 {margin-right: 12px;}.mb1_5 {margin-bottom: 12px;}.ml1_5 {margin-left: 12px;}.mx1_5 {margin-left: 12px;margin-right: 12px;}.my1_5 {margin-bottom: 12px;margin-top: 12px;}.m2 {margin: 16px;}.mt2 {margin-top: 16px;}.mr2 {margin-right: 16px;}.mb2 {margin-bottom: 16px;}.ml2 {margin-left: 16px;}.mx2 {margin-left: 16px;margin-right: 16px;}.my2 {margin-bottom: 16px;margin-top: 16px;}.m3 {margin: 24px;}.mt3 {margin-top: 24px;}.mr3 {margin-right: 24px;}.mb3 {margin-bottom: 24px;}.ml3 {margin-left: 24px;}.mx3 {margin-left: 24px;margin-right: 24px;}.my3 {margin-bottom: 24px;margin-top: 24px;}.m4 {margin: 32px;}.mt4 {margin-top: 32px;}.mr4 {margin-right: 32px;}.mb4 {margin-bottom: 32px;}.ml4 {margin-left: 32px;}.mx4 {margin-left: 32px;margin-right: 32px;}.my4 {margin-bottom: 32px;margin-top: 32px;}.m5 {margin: 40px;}.mt5 {margin-top: 40px;}.mr5 {margin-right: 40px;}.mb5 {margin-bottom: 40px;}.ml5 {margin-left: 40px;}.mx5 {margin-left: 40px;margin-right: 40px;}.my5 {margin-bottom: 40px;margin-top: 40px;}.m10 {margin: 80px;}.mt10 {margin-top: 80px;}.mr10 {margin-right: 80px;}.mb10 {margin-bottom: 80px;}.ml10 {margin-left: 80px;}.mx10 {margin-left: 80px;margin-right: 80px;}.my10 {margin-bottom: 80px;margin-top: 80px;}.mn1 {margin: -8px;}.mtn1 {margin-top: -8px;}.mrn1 {margin-right: -8px;}.mbn1 {margin-bottom: -8px;}.mln1 {margin-left: -8px;}.mxn1 {margin-left: -8px;margin-right: -8px;}.myn1 {margin-bottom: -8px;margin-top: -8px;}.mxn2 {margin-left: -16px;margin-right: -16px;}.mxn3 {margin-left: -24px;margin-right: -24px;}.mxn4 {margin-left: -32px;margin-right: -32px;}.mt-auto {margin-top: auto;}.mb-auto {margin-bottom: auto;}.my-auto {margin-top: auto;margin-bottom: auto;}.ml-auto {margin-left: auto;}.mr-auto {margin-right: auto;}.mx-auto {margin-left: auto;margin-right: auto;}.opacity-0 {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.opacity-0_1 {opacity: 0.1;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=10)";filter: alpha(opacity=10);}.opacity-0_2 {opacity: 0.2;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=20)";filter: alpha(opacity=20);}.opacity-0_3 {opacity: 0.3;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=30)";filter: alpha(opacity=30);}.opacity-0_4 {opacity: 0.4;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=40)";filter: alpha(opacity=40);}.opacity-0_5 {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.opacity-0_6 {opacity: 0.6;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=60)";filter: alpha(opacity=60);}.opacity-0_7 {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.opacity-0_8 {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.opacity-0_9 {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.opacity-1 {opacity: 1;-ms-filter: none;filter: none;}.outline-none {outline: 0;}.p0 {padding: 0;}.pt0 {padding-top: 0;}.pr0 {padding-right: 0;}.pb0 {padding-bottom: 0;}.pl0 {padding-left: 0;}.px0 {padding-left: 0;padding-right: 0;}.py0 {padding-bottom: 0;padding-top: 0;}.p0_5 {padding: 4px;}.pt0_5 {padding-top: 4px;}.pr0_5 {padding-right: 4px;}.pb0_5 {padding-bottom: 4px;}.pl0_5 {padding-left: 4px;}.px0_5 {padding-left: 4px;padding-right: 4px;}.py0_5 {padding-bottom: 4px;padding-top: 4px;}.p1 {padding: 8px;}.pt1 {padding-top: 8px;}.pr1 {padding-right: 8px;}.pb1 {padding-bottom: 8px;}.pl1 {padding-left: 8px;}.py1 {padding-bottom: 8px;padding-top: 8px;}.px1 {padding-left: 8px;padding-right: 8px;}.p1_5 {padding: 12px;}.pt1_5 {padding-top: 12px;}.pr1_5 {padding-right: 12px;}.pb1_5 {padding-bottom: 12px;}.pl1_5 {padding-left: 12px;}.px1_5 {padding-left: 12px;padding-right: 12px;}.py1_5 {padding-bottom: 12px;padding-top: 12px;}.p2 {padding: 16px;}.pt2 {padding-top: 16px;}.pr2 {padding-right: 16px;}.pb2 {padding-bottom: 16px;}.pl2 {padding-left: 16px;}.py2 {padding-bottom: 16px;padding-top: 16px;}.px2 {padding-left: 16px;padding-right: 16px;}.p3 {padding: 24px;}.pt3 {padding-top: 24px;}.pr3 {padding-right: 24px;}.pb3 {padding-bottom: 24px;}.pl3 {padding-left: 24px;}.py3 {padding-bottom: 24px;padding-top: 24px;}.px3 {padding-left: 24px;padding-right: 24px;}.p4 {padding: 32px;}.pt4 {padding-top: 32px;}.pr4 {padding-right: 32px;}.pb4 {padding-bottom: 32px;}.pl4 {padding-left: 32px;}.py4 {padding-bottom: 32px;padding-top: 32px;}.px4 {padding-left: 32px;padding-right: 32px;}.p5 {padding: 40px;}.pt5 {padding-top: 40px;}.pr5 {padding-right: 40px;}.pb5 {padding-bottom: 40px;}.pl5 {padding-left: 40px;}.py5 {padding-bottom: 40px;padding-top: 40px;}.px5 {padding-left: 40px;padding-right: 40px;}.p10 {padding: 80px;}.pt10 {padding-top: 80px;}.pr10 {padding-right: 80px;}.pb10 {padding-bottom: 80px;}.pl10 {padding-left: 80px;}.py10 {padding-bottom: 80px;padding-top: 80px;}.px10 {padding-left: 80px;padding-right: 80px;}.pointer-events-none {pointer-events: none;}.relative {position: relative;}.absolute {position: absolute;}.sticky {position: sticky;}.top-0 {top: 0;}.right-0 {right: 0;}.bottom-0 {bottom: 0;}.left-0 {left: 0;}.height-full {height: 100%;}.width-full {width: 100%;}.max-width-full {max-width: 100%;}.width-0 {width: 0;}.height-0 {height: 0;}.width-auto {width: auto;}.min-width-1 {min-width: 8px;}.min-height-1 {min-height: 8px;}.max-width-1 {max-width: 8px;}.max-height-1 {max-height: 8px;}.min-width-2 {min-width: 16px;}.min-height-2 {min-height: 16px;}.max-width-2 {max-width: 16px;}.max-height-2 {max-height: 16px;}.min-width-3 {min-width: 24px;}.min-height-3 {min-height: 24px;}.max-width-3 {max-width: 24px;}.max-height-3 {max-height: 24px;}.min-width-4 {min-width: 32px;}.min-height-4 {min-height: 32px;}.max-width-4 {max-width: 32px;}.max-height-4 {max-height: 32px;}.min-width-5 {min-width: 40px;}.min-height-5 {min-height: 40px;}.max-width-5 {max-width: 40px;}.max-height-5 {max-height: 40px;}.min-width-6 {min-width: 48px;}.min-height-6 {min-height: 48px;}.max-width-6 {max-width: 48px;}.max-height-6 {max-height: 48px;}.min-width-7 {min-width: 56px;}.min-height-7 {min-height: 56px;}.max-width-7 {max-width: 56px;}.max-height-7 {max-height: 56px;}.min-width-8 {min-width: 64px;}.min-height-8 {min-height: 64px;}.max-width-8 {max-width: 64px;}.max-height-8 {max-height: 64px;}.min-width-9 {min-width: 72px;}.min-height-9 {min-height: 72px;}.max-width-9 {max-width: 72px;}.max-height-9 {max-height: 72px;}.min-width-10 {min-width: 80px;}.min-height-10 {min-height: 80px;}.max-width-10 {max-width: 80px;}.max-height-10 {max-height: 80px;}.min-width-11 {min-width: 88px;}.min-height-11 {min-height: 88px;}.max-width-11 {max-width: 88px;}.max-height-11 {max-height: 88px;}.min-width-12 {min-width: 96px;}.min-height-12 {min-height: 96px;}.max-width-12 {max-width: 96px;}.max-height-12 {max-height: 96px;}.min-width-13 {min-width: 104px;}.min-height-13 {min-height: 104px;}.max-width-13 {max-width: 104px;}.max-height-13 {max-height: 104px;}.min-width-14 {min-width: 112px;}.min-height-14 {min-height: 112px;}.max-width-14 {max-width: 112px;}.max-height-14 {max-height: 112px;}.min-width-15 {min-width: 120px;}.min-height-15 {min-height: 120px;}.max-width-15 {max-width: 120px;}.max-height-15 {max-height: 120px;}.min-width-16 {min-width: 128px;}.min-height-16 {min-height: 128px;}.max-width-16 {max-width: 128px;}.max-height-16 {max-height: 128px;}.min-width-17 {min-width: 136px;}.min-height-17 {min-height: 136px;}.max-width-17 {max-width: 136px;}.max-height-17 {max-height: 136px;}.min-width-18 {min-width: 144px;}.min-height-18 {min-height: 144px;}.max-width-18 {max-width: 144px;}.max-height-18 {max-height: 144px;}.min-width-19 {min-width: 152px;}.min-height-19 {min-height: 152px;}.max-width-19 {max-width: 152px;}.max-height-19 {max-height: 152px;}.min-width-20 {min-width: 160px;}.min-height-20 {min-height: 160px;}.max-width-20 {max-width: 160px;}.max-height-20 {max-height: 160px;}.min-width-21 {min-width: 168px;}.min-height-21 {min-height: 168px;}.max-width-21 {max-width: 168px;}.max-height-21 {max-height: 168px;}.min-width-22 {min-width: 176px;}.min-height-22 {min-height: 176px;}.max-width-22 {max-width: 176px;}.max-height-22 {max-height: 176px;}.min-width-23 {min-width: 184px;}.min-height-23 {min-height: 184px;}.max-width-23 {max-width: 184px;}.max-height-23 {max-height: 184px;}.min-width-24 {min-width: 192px;}.min-height-24 {min-height: 192px;}.max-width-24 {max-width: 192px;}.max-height-24 {max-height: 192px;}.min-width-25 {min-width: 200px;}.min-height-25 {min-height: 200px;}.max-width-25 {max-width: 200px;}.max-height-25 {max-height: 200px;}.min-width-26 {min-width: 208px;}.min-height-26 {min-height: 208px;}.max-width-26 {max-width: 208px;}.max-height-26 {max-height: 208px;}.min-width-27 {min-width: 216px;}.min-height-27 {min-height: 216px;}.max-width-27 {max-width: 216px;}.max-height-27 {max-height: 216px;}.min-width-28 {min-width: 224px;}.min-height-28 {min-height: 224px;}.max-width-28 {max-width: 224px;}.max-height-28 {max-height: 224px;}.min-width-29 {min-width: 232px;}.min-height-29 {min-height: 232px;}.max-width-29 {max-width: 232px;}.max-height-29 {max-height: 232px;}.min-width-30 {min-width: 240px;}.min-height-30 {min-height: 240px;}.max-width-30 {max-width: 240px;}.max-height-30 {max-height: 240px;}.min-width-40 {min-width: 320px;}.min-height-40 {min-height: 320px;}.max-width-40 {max-width: 320px;}.max-height-40 {max-height: 320px;}.min-width-50 {min-width: 400px;}.min-height-50 {min-height: 400px;}.max-width-50 {max-width: 400px;}.max-height-50 {max-height: 400px;}.min-width-60 {min-width: 480px;}.min-height-60 {min-height: 480px;}.max-width-60 {max-width: 480px;}.max-height-60 {max-height: 480px;}.min-width-70 {min-width: 560px;}.min-height-70 {min-height: 560px;}.max-width-70 {max-width: 560px;}.max-height-70 {max-height: 560px;}.min-width-80 {min-width: 640px;}.min-height-80 {min-height: 640px;}.max-width-80 {max-width: 640px;}.max-height-80 {max-height: 640px;}.min-width-90 {min-width: 720px;}.min-height-90 {min-height: 720px;}.max-width-90 {max-width: 720px;}.max-height-90 {max-height: 720px;}.min-width-100 {min-width: 800px;}.min-height-100 {min-height: 800px;}.max-width-100 {max-width: 800px;}.max-height-100 {max-height: 800px;}.min-width-110 {min-width: 880px;}.min-height-110 {min-height: 880px;}.max-width-110 {max-width: 880px;}.max-height-110 {max-height: 880px;}.min-width-120 {min-width: 960px;}.min-height-120 {min-height: 960px;}.max-width-120 {max-width: 960px;}.max-height-120 {max-height: 960px;}.min-width-36 {min-width: 288px;}.max-height-51 {max-height: 408px;}.max-height-inherit {max-height: inherit;}.valign-baseline {vertical-align: baseline;}.valign-text-top {vertical-align: text-top;}.valign-top {vertical-align: top;}.valign-middle {vertical-align: middle;}.valign-bottom {vertical-align: bottom;}.font-family-inherit {font-family: inherit;}.font-size-inherit {font-size: inherit;}.text-decoration-none {text-decoration: none;}.bold {font-weight: bold;}.regular {font-weight: normal;}.italic {font-style: italic;}.strikethrough {text-decoration: line-through;}.underline {text-decoration: underline;}.caps {text-transform: uppercase;letter-spacing: 1px;}.lowercase {text-transform: lowercase;}.capitalize {text-transform: capitalize;}.align-left {text-align: left;}.align-center {text-align: center;}.align-right {text-align: right;}.align-justify {text-align: justify;}.nowrap {white-space: nowrap;}.break-word {word-wrap: break-word;}.line-height-1 {line-height: 24px;}.line-height-2 {line-height: 48px;}.line-height-3 {line-height: 72px;}.line-height-4 {line-height: 96px;}.list-style-none {list-style: none;}.ellipsis {overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;white-space: nowrap;}.list-reset {list-style: none;padding-left: 0;}.text-overflow-initial {-o-text-overflow: initial;text-overflow: initial;}.transition-property-all {-webkit-transition-property: all;-moz-transition-property: all;-o-transition-property: all;-ms-transition-property: all;transition-property: all;}.transition-property-opacity {-webkit-transition-property: opacity;-moz-transition-property: opacity;-o-transition-property: opacity;-ms-transition-property: opacity;transition-property: opacity;}.transition-duration-sec1 {-webkit-transition-duration: 1s;-moz-transition-duration: 1s;-o-transition-duration: 1s;-ms-transition-duration: 1s;transition-duration: 1s;}.transition-duration-sec1_5 {-webkit-transition-duration: 1.5s;-moz-transition-duration: 1.5s;-o-transition-duration: 1.5s;-ms-transition-duration: 1.5s;transition-duration: 1.5s;}.transition-duration-sec2 {-webkit-transition-duration: 2s;-moz-transition-duration: 2s;-o-transition-duration: 2s;-ms-transition-duration: 2s;transition-duration: 2s;}.transition-duration-sec2_5 {-webkit-transition-duration: 2.5s;-moz-transition-duration: 2.5s;-o-transition-duration: 2.5s;-ms-transition-duration: 2.5s;transition-duration: 2.5s;}.transition-duration-sec3 {-webkit-transition-duration: 3s;-moz-transition-duration: 3s;-o-transition-duration: 3s;-ms-transition-duration: 3s;transition-duration: 3s;}.transition-duration-sec3_5 {-webkit-transition-duration: 3.5s;-moz-transition-duration: 3.5s;-o-transition-duration: 3.5s;-ms-transition-duration: 3.5s;transition-duration: 3.5s;}.transition-duration-sec4 {-webkit-transition-duration: 4s;-moz-transition-duration: 4s;-o-transition-duration: 4s;-ms-transition-duration: 4s;transition-duration: 4s;}.transition-duration-sec4_5 {-webkit-transition-duration: 4.5s;-moz-transition-duration: 4.5s;-o-transition-duration: 4.5s;-ms-transition-duration: 4.5s;transition-duration: 4.5s;}.transition-duration-sec5 {-webkit-transition-duration: 5s;-moz-transition-duration: 5s;-o-transition-duration: 5s;-ms-transition-duration: 5s;transition-duration: 5s;}.transition-duration-sec6 {-webkit-transition-duration: 6s;-moz-transition-duration: 6s;-o-transition-duration: 6s;-ms-transition-duration: 6s;transition-duration: 6s;}.transition-duration-sec7 {-webkit-transition-duration: 7s;-moz-transition-duration: 7s;-o-transition-duration: 7s;-ms-transition-duration: 7s;transition-duration: 7s;}.transition-duration-sec8 {-webkit-transition-duration: 8s;-moz-transition-duration: 8s;-o-transition-duration: 8s;-ms-transition-duration: 8s;transition-duration: 8s;}.transition-duration-sec9 {-webkit-transition-duration: 9s;-moz-transition-duration: 9s;-o-transition-duration: 9s;-ms-transition-duration: 9s;transition-duration: 9s;}.transition-duration-sec10 {-webkit-transition-duration: 10s;-moz-transition-duration: 10s;-o-transition-duration: 10s;-ms-transition-duration: 10s;transition-duration: 10s;}.transition-duration-ms100 {-webkit-transition-duration: 100ms;-moz-transition-duration: 100ms;-o-transition-duration: 100ms;-ms-transition-duration: 100ms;transition-duration: 100ms;}.transition-duration-ms200 {-webkit-transition-duration: 200ms;-moz-transition-duration: 200ms;-o-transition-duration: 200ms;-ms-transition-duration: 200ms;transition-duration: 200ms;}.transition-duration-ms300 {-webkit-transition-duration: 300ms;-moz-transition-duration: 300ms;-o-transition-duration: 300ms;-ms-transition-duration: 300ms;transition-duration: 300ms;}.transition-duration-ms400 {-webkit-transition-duration: 400ms;-moz-transition-duration: 400ms;-o-transition-duration: 400ms;-ms-transition-duration: 400ms;transition-duration: 400ms;}.transition-duration-ms500 {-webkit-transition-duration: 500ms;-moz-transition-duration: 500ms;-o-transition-duration: 500ms;-ms-transition-duration: 500ms;transition-duration: 500ms;}.transition-duration-ms600 {-webkit-transition-duration: 600ms;-moz-transition-duration: 600ms;-o-transition-duration: 600ms;-ms-transition-duration: 600ms;transition-duration: 600ms;}.transition-duration-ms700 {-webkit-transition-duration: 700ms;-moz-transition-duration: 700ms;-o-transition-duration: 700ms;-ms-transition-duration: 700ms;transition-duration: 700ms;}.transition-duration-ms800 {-webkit-transition-duration: 800ms;-moz-transition-duration: 800ms;-o-transition-duration: 800ms;-ms-transition-duration: 800ms;transition-duration: 800ms;}.transition-duration-ms900 {-webkit-transition-duration: 900ms;-moz-transition-duration: 900ms;-o-transition-duration: 900ms;-ms-transition-duration: 900ms;transition-duration: 900ms;}.transition-tf-ease {-webkit-transition-timing-function: ease;-moz-transition-timing-function: ease;-o-transition-timing-function: ease;-ms-transition-timing-function: ease;transition-timing-function: ease;}.transition-tf-linear {-webkit-transition-timing-function: linear;-moz-transition-timing-function: linear;-o-transition-timing-function: linear;-ms-transition-timing-function: linear;transition-timing-function: linear;}.transition-tf-ease-in {-webkit-transition-timing-function: ease-in;-moz-transition-timing-function: ease-in;-o-transition-timing-function: ease-in;-ms-transition-timing-function: ease-in;transition-timing-function: ease-in;}.transition-tf-ease-out {-webkit-transition-timing-function: ease-out;-moz-transition-timing-function: ease-out;-o-transition-timing-function: ease-out;-ms-transition-timing-function: ease-out;transition-timing-function: ease-out;}.transition-tf-ease-in-out {-webkit-transition-timing-function: ease-in-out;-moz-transition-timing-function: ease-in-out;-o-transition-timing-function: ease-in-out;-ms-transition-timing-function: ease-in-out;transition-timing-function: ease-in-out;}.transition-tf-step-start {-webkit-transition-timing-function: step-start;-moz-transition-timing-function: step-start;-o-transition-timing-function: step-start;-ms-transition-timing-function: step-start;transition-timing-function: step-start;}.transition-tf-step-end {-webkit-transition-timing-function: step-end;-moz-transition-timing-function: step-end;-o-transition-timing-function: step-end;-ms-transition-timing-function: step-end;transition-timing-function: step-end;}.transition-delay-sec1 {-webkit-transition-delay: 1s;-moz-transition-delay: 1s;-o-transition-delay: 1s;-ms-transition-delay: 1s;transition-delay: 1s;}.transition-delay-sec1_5 {-webkit-transition-delay: 1.5s;-moz-transition-delay: 1.5s;-o-transition-delay: 1.5s;-ms-transition-delay: 1.5s;transition-delay: 1.5s;}.transition-delay-sec2 {-webkit-transition-delay: 2s;-moz-transition-delay: 2s;-o-transition-delay: 2s;-ms-transition-delay: 2s;transition-delay: 2s;}.transition-delay-sec2_5 {-webkit-transition-delay: 2.5s;-moz-transition-delay: 2.5s;-o-transition-delay: 2.5s;-ms-transition-delay: 2.5s;transition-delay: 2.5s;}.transition-delay-sec3 {-webkit-transition-delay: 3s;-moz-transition-delay: 3s;-o-transition-delay: 3s;-ms-transition-delay: 3s;transition-delay: 3s;}.transition-delay-sec3_5 {-webkit-transition-delay: 3.5s;-moz-transition-delay: 3.5s;-o-transition-delay: 3.5s;-ms-transition-delay: 3.5s;transition-delay: 3.5s;}.transition-delay-sec4 {-webkit-transition-delay: 4s;-moz-transition-delay: 4s;-o-transition-delay: 4s;-ms-transition-delay: 4s;transition-delay: 4s;}.transition-delay-sec4_5 {-webkit-transition-delay: 4.5s;-moz-transition-delay: 4.5s;-o-transition-delay: 4.5s;-ms-transition-delay: 4.5s;transition-delay: 4.5s;}.transition-delay-sec5 {-webkit-transition-delay: 5s;-moz-transition-delay: 5s;-o-transition-delay: 5s;-ms-transition-delay: 5s;transition-delay: 5s;}.transition-delay-sec6 {-webkit-transition-delay: 6s;-moz-transition-delay: 6s;-o-transition-delay: 6s;-ms-transition-delay: 6s;transition-delay: 6s;}.transition-delay-sec7 {-webkit-transition-delay: 7s;-moz-transition-delay: 7s;-o-transition-delay: 7s;-ms-transition-delay: 7s;transition-delay: 7s;}.transition-delay-sec8 {-webkit-transition-delay: 8s;-moz-transition-delay: 8s;-o-transition-delay: 8s;-ms-transition-delay: 8s;transition-delay: 8s;}.transition-delay-sec9 {-webkit-transition-delay: 9s;-moz-transition-delay: 9s;-o-transition-delay: 9s;-ms-transition-delay: 9s;transition-delay: 9s;}.transition-delay-sec10 {-webkit-transition-delay: 10s;-moz-transition-delay: 10s;-o-transition-delay: 10s;-ms-transition-delay: 10s;transition-delay: 10s;}.transition-delay-ms100 {-webkit-transition-delay: 100ms;-moz-transition-delay: 100ms;-o-transition-delay: 100ms;-ms-transition-delay: 100ms;transition-delay: 100ms;}.transition-delay-ms200 {-webkit-transition-delay: 200ms;-moz-transition-delay: 200ms;-o-transition-delay: 200ms;-ms-transition-delay: 200ms;transition-delay: 200ms;}.transition-delay-ms300 {-webkit-transition-delay: 300ms;-moz-transition-delay: 300ms;-o-transition-delay: 300ms;-ms-transition-delay: 300ms;transition-delay: 300ms;}.transition-delay-ms400 {-webkit-transition-delay: 400ms;-moz-transition-delay: 400ms;-o-transition-delay: 400ms;-ms-transition-delay: 400ms;transition-delay: 400ms;}.transition-delay-ms500 {-webkit-transition-delay: 500ms;-moz-transition-delay: 500ms;-o-transition-delay: 500ms;-ms-transition-delay: 500ms;transition-delay: 500ms;}.transition-delay-ms600 {-webkit-transition-delay: 600ms;-moz-transition-delay: 600ms;-o-transition-delay: 600ms;-ms-transition-delay: 600ms;transition-delay: 600ms;}.transition-delay-ms700 {-webkit-transition-delay: 700ms;-moz-transition-delay: 700ms;-o-transition-delay: 700ms;-ms-transition-delay: 700ms;transition-delay: 700ms;}.transition-delay-ms800 {-webkit-transition-delay: 800ms;-moz-transition-delay: 800ms;-o-transition-delay: 800ms;-ms-transition-delay: 800ms;transition-delay: 800ms;}.transition-delay-ms900 {-webkit-transition-delay: 900ms;-moz-transition-delay: 900ms;-o-transition-delay: 900ms;-ms-transition-delay: 900ms;transition-delay: 900ms;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5 {color: #fff;}.theme-inverse a {color: inherit;}.theme-inverse a:hover {color: #a6daff;}.theme-inverse a:active {color: #bfe5ff;}.theme-inverse a.text-muted {color: #b1b1b3;}.theme-inverse hr {background: #555659;}.theme-inverse .mo-identicon {background-color: #555659;color: #fff;}.theme-inverse .menu-row.hover {background: #222326;}.theme-inverse .menu-row.active {color: #fff;background: #222326;}.theme-inverse .menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse a.menu-row {color: inherit;}.theme-inverse a.menu-row:hover {background: #222326;}.theme-inverse a.menu-row:active {color: #fff;background: #222326;}.theme-inverse .menu-divider {border-color: #555659;}.theme-inverse .text-color-heading {color: #fff;}.theme-inverse .text-color-body {color: #d7d7d9;}.theme-inverse .text-muted {color: #b1b1b3;}.theme-inverse .text-positive {color: #8ae58a;}.theme-inverse .text-muted-positive {color: #39bf71;}.theme-inverse .text-negative {color: #f99;}.theme-inverse .text-muted-negative {color: #f26161;}.theme-inverse .nav-link,.momentum-body .theme-inverse .nav-link {color: #b1b1b3;}.theme-inverse .nav-link:hover,.momentum-body .theme-inverse .nav-link:hover {color: #a6daff;}.theme-inverse .nav-link:active,.momentum-body .theme-inverse .nav-link:active {color: #bfe5ff;}.theme-inverse a.tab-link,.momentum-body .theme-inverse a.tab-link {color: #d7d7d9;}.theme-inverse a.tab-link:hover,.momentum-body .theme-inverse a.tab-link:hover {border-bottom-color: #969799;color: #fff;}.theme-inverse a.tab-link:active,.momentum-body .theme-inverse a.tab-link:active {border-bottom-color: #d7d7d9;color: #d7d7d9;}.theme-inverse a.tab-link.selected,.momentum-body .theme-inverse a.tab-link.selected {color: #fff;}.theme-inverse .list-row {border-bottom: 1px solid #555659;border-top: 1px solid #555659;}.theme-inverse .upload {background-color: #3b3d3f;border-color: #555659;color: #969799;}.theme-inverse .upload:hover,.theme-inverse .upload.hover {background-color: #707173;}.theme-inverse .border {border-color: #555659;}.theme-inverse .border-top {border-top-color: #555659;}.theme-inverse .border-right {border-right-color: #555659;}.theme-inverse .border-bottom {border-bottom-color: #555659;}.theme-inverse .border-left {border-left-color: #555659;}@media (max-width: 575px) {.display-none-xs {display: none;}.display-inline-xs,.inline-xs {display: inline;}.display-block-cx,.block-xs {display: block;}.display-inline-block-xs,.inline-block-xs {display: inline-block;}.display-table-xs,.table-xs {display: table;}.display-table-cell-xs,.table-cell-xs {display: table-cell;}.display-flex-xs,.flex-xs {display: flex;}}@media (min-width: 576px) {.container,.container-sm {max-width: 540px;width: auto;}.col-sm {flex: 1 1 0%;min-width: 0;width: 100%;}.col-sm-auto {flex: 0 0 auto;width: auto;}.col-sm-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-sm-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-sm-3 {flex: 0 0 25%;max-width: 25%;}.col-sm-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-sm-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-sm-6 {flex: 0 0 50%;max-width: 50%;}.col-sm-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-sm-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-sm-9 {flex: 0 0 75%;max-width: 75%;}.col-sm-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-sm-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-sm-12 {flex: 0 0 100%;max-width: 100%;}.display-none-sm {display: none;}.display-inline-sm {display: inline;}.display-block-sm {display: block;}.display-inline-block-sm {display: inline-block;}.display-table-sm {display: table;}.display-table-cell-sm {display: table-cell;}.display-flex-sm {display: flex;}}@media (min-width: 768px) {.container,.container-sm,.container-md {max-width: 720px;width: auto;}.col-md {flex: 1 1 0%;min-width: 0;width: 100%;}.col-md-auto {flex: 0 0 auto;width: auto;}.col-md-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-md-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-md-3 {flex: 0 0 25%;max-width: 25%;}.col-md-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-md-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-md-6 {flex: 0 0 50%;max-width: 50%;}.col-md-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-md-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-md-9 {flex: 0 0 75%;max-width: 75%;}.col-md-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-md-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-md-12 {flex: 0 0 100%;max-width: 100%;}.display-none-md {display: none;}.display-inline-md {display: inline;}.display-block-md {display: block;}.display-inline-block-md {display: inline-block;}.display-table-md {display: table;}.display-table-cell-md {display: table-cell;}.display-flex-md {display: flex;}}@media (min-width: 992px) {.container,.container-sm,.container-md,.container-lg {max-width: 960px;width: auto;}.col-lg {flex: 1 1 0%;min-width: 0;width: 100%;}.col-lg-auto {flex: 0 0 auto;width: auto;}.col-lg-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-lg-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-lg-3 {flex: 0 0 25%;max-width: 25%;}.col-lg-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-lg-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-lg-6 {flex: 0 0 50%;max-width: 50%;}.col-lg-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-lg-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-lg-9 {flex: 0 0 75%;max-width: 75%;}.col-lg-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-lg-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-lg-12 {flex: 0 0 100%;max-width: 100%;}.display-none-lg {display: none;}.display-inline-lg {display: inline;}.display-block-lg {display: block;}.display-inline-block-lg {display: inline-block;}.display-table-lg {display: table;}.display-table-cell-lg {display: table-cell;}.display-flex-lg {display: flex;}}@media (min-width: 1200px) {.container,.container-sm,.container-md,.container-lg,.container-xl {max-width: 1140px;width: auto;}.col-xl {flex: 1 1 0%;min-width: 0;width: 100%;}.col-xl-auto {flex: 0 0 auto;width: auto;}.col-xl-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-xl-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-xl-3 {flex: 0 0 25%;max-width: 25%;}.col-xl-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-xl-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-xl-6 {flex: 0 0 50%;max-width: 50%;}.col-xl-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-xl-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-xl-9 {flex: 0 0 75%;max-width: 75%;}.col-xl-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-xl-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-xl-12 {flex: 0 0 100%;max-width: 100%;}.display-none-xl {display: none;}.display-inline-xl {display: inline;}.display-block-xl {display: block;}.display-inline-block-xl {display: inline-block;}.display-table-xl {display: table;}.display-table-cell-xl {display: table-cell;}.display-flex-xl {display: flex;}}html {position: relative;min-height: 100%;}body {background: #f9f9f9;color: #515357;padding-top: 70px;padding-bottom: 250px;}a,a:visited {color: #737578;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.ttf") format('truetype');font-style: normal;font-weight: bold;text-rendering: optimizeLegibility;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.ttf") format('truetype');font-style: normal;font-weight: normal;text-rendering: optimizeLegibility;}body,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {color: #515357;font: normal 400 16px/1.8 Lato;}h1,h2,h3,h4,p,h5,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;display: block;}h1 {font: normal 700 48px/1.4 Lato;color: #fff;text-transform: uppercase;letter-spacing: 1px;}h2,h5 {font: normal 400 36px/1.4 Lato;color: #515357;text-transform: none;letter-spacing: 0px;}h3 {font: normal 700 18px/1.4 "Lato";color: #515357;}h4 {font: normal 700 16px/1.4 Lato;text-transform: uppercase;letter-spacing: 1px;color: #515357;}h5 {font-size: 24px;margin-right: 115px;overflow: hidden;-webkit-transition: color 150ms;-moz-transition: color 150ms;-o-transition: color 150ms;-ms-transition: color 150ms;transition: color 150ms;}h2,h3,h4 {margin: 17.5px 0;}p,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 17.5px 0;}p > a,.postings-link {text-decoration: underline;color: #737578;}p > a:hover,.postings-link:hover {color: #579eee;}p > a:active,.postings-link:active,p > a:focus,.postings-link:focus {color: #3c6ea6;}.page-full-width {width: 100%;}.page-centered,.g-recaptcha div,.h-captcha-spacing {display: block;margin: 0 auto;max-width: 1080px;}.content-wrapper {min-height: 100%;}.content {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;min-height: 100%;position: relative;width: 100%;}.row {left: 0;position: absolute;right: 0;}.column-wrapper {display: table;height: 100%;width: 100%;}.table-row {display: table-row;}.column {display: table-cell;position: relative;vertical-align: middle;}.third {width: 33.33%;}.two-thirds {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;padding-left: 40px;width: 66.67%;}.section-wrapper {padding: 0 30px;}.section {padding: 20px 0;position: relative;}.narrow-section,.application .section,.eeo-survey .section,.list .section,.show .section {max-width: 760px;padding-left: 0;padding-right: 0;}.accent-section {background: #fff;}.accent-section.small-accent {padding: 0 30px;}.accent-section .posting-categories {margin: 20px 0;}.accent-section .posting-category {display: inline-block;font-size: 14px;margin-right: 10px;}.split-width-container,.show .posting-header {display: block;}.left-block,.right-block,.left-float,.right-float,.full-block {display: block;width: auto;}.left-block {overflow: hidden;}.right-float {float: right;margin-left: 10px;}.right-block {overflow: hidden;}.left-float {float: left;margin-right: 10px;}.full-block {width: 100%;}.template-btn,.template-btn-submit,.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {font: normal 700 14px/1.4 Lato;text-transform: uppercase;letter-spacing: 2px;text-align: center;border-radius: 3px;color: #fff;background: #00a1dc;height: auto;position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 10px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.template-btn .filename,.template-btn-submit .filename,.template-btn-utility .filename,.sort-category .filename,.application .application-field .upload-file-overlay .filename,.eeo-survey .application-field .upload-file-overlay .filename,.list .filter-button-wrapper .filter-button .filename,.template-btn .default-label,.template-btn-submit .default-label,.template-btn-utility .default-label,.sort-category .default-label,.application .application-field .upload-file-overlay .default-label,.eeo-survey .application-field .upload-file-overlay .default-label,.list .filter-button-wrapper .filter-button .default-label {line-height: 1.33;display: block;overflow: hidden;}.template-btn:visited,.template-btn-submit:visited,.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {color: #fff;}.template-btn .icon >svg,.template-btn-submit .icon >svg,.template-btn-utility .icon >svg,.sort-category .icon >svg,.application .application-field .upload-file-overlay .icon >svg,.eeo-survey .application-field .upload-file-overlay .icon >svg,.list .filter-button-wrapper .filter-button .icon >svg {fill: #fff;}.template-btn:hover,.template-btn-submit:hover,.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {color: #fff;}.template-btn:active,.template-btn-submit:active,.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #00709a;}.template-btn-submit {color: #fff;background: #00a1dc;border-color: #0098d1;}.template-btn-submit .icon >svg {fill: #fff;}.template-btn-submit:visited {color: #fff;}.template-btn-submit:hover {background: #0090c6;}.template-btn-submit:active,.template-btn-submit:focus {background: #00709a;}.template-btn-submit.cerulean {background-color: #0c92f3;border-color: #0b8ae6;}.template-btn-submit.cerulean:hover {background: #0a83da;}.template-btn-submit.cerulean:active,.template-btn-submit.cerulean:focus {background: #0866aa;}.template-btn-submit.teal {background-color: #1cadba;border-color: #1aa4b0;}.template-btn-submit.teal:hover {background: #199ba7;}.template-btn-submit.teal:active,.template-btn-submit.teal:focus {background: #137982;}.template-btn-submit.shamrock {background-color: #39bf71;border-color: #36b56b;}.template-btn-submit.shamrock:hover {background: #33ab65;}.template-btn-submit.shamrock:active,.template-btn-submit.shamrock:focus {background: #27854f;}.template-btn-submit.golden-poppy {background-color: #ffa60d;border-color: #f29d0c;}.template-btn-submit.golden-poppy:hover {background: #e5950b;}.template-btn-submit.golden-poppy:active,.template-btn-submit.golden-poppy:focus {background: #b27409;}.template-btn-submit.ruby {background-color: #d94141;border-color: #ce3d3d;}.template-btn-submit.ruby:hover {background: #c33a3a;}.template-btn-submit.ruby:active,.template-btn-submit.ruby:focus {background: #972d2d;}.template-btn-submit.ash {background-color: #969799;border-color: #8e8f91;}.template-btn-submit.ash:hover {background: #878789;}.template-btn-submit.ash:active,.template-btn-submit.ash:focus {background: #69696b;}.template-btn-submit.black {background-color: #000;border-color: #000;}.template-btn-submit.black:hover {background: #000;}.template-btn-submit.black:active,.template-btn-submit.black:focus {background: #000;}.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {background: #ebecf0;color: #9696a2;border: 1px solid #dfe0e4;}.template-btn-utility >svg,.sort-category >svg,.application .application-field .upload-file-overlay >svg,.eeo-survey .application-field .upload-file-overlay >svg,.list .filter-button-wrapper .filter-button >svg {fill: #9696a2;}.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited {color: #9696a2;background: #ebecf0;}.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {background: #dfe0e4;color: #5a5a61;}.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #d3d4d8;color: #5a5a61;}.template-btn-utility.has-file,.sort-category.has-file,.application .application-field .upload-file-overlay.has-file,.eeo-survey .application-field .upload-file-overlay.has-file,.list .filter-button-wrapper .filter-button.has-file {background: #dadbdf;}.template-btn .icon,.template-btn-submit .icon,.template-btn-utility .icon,.sort-category .icon,.application .application-field .upload-file-overlay .icon,.eeo-survey .application-field .upload-file-overlay .icon,.list .filter-button-wrapper .filter-button .icon {position: absolute;left: 15px;top: calc(50% - 8px);}.posting-btn-submit {padding: 5px 15px;}.main-header {background: #fff;color: #515357;}.main-header.section-wrapper,.main-header .section {padding-top: 0px;padding-bottom: 0px;}.main-header .main-header-logo {margin: 17.5px 0px;display: inline-block;}.main-header .main-header-logo img {height: 35px;}.main-header .mobile-menu svg >path {fill: #515357;}.main-header .main-header-content {display: block;height: 100%;margin: 0px auto;color: #515357;}.main-header .main-header-content .main-header-company {display: inline-block;height: 70px;vertical-align: middle;font-family: Lato;color: #515357;}.main-header {top: 0;height: 70px;}.main-header .main-logo,.main-header .mobile-menu {position: absolute;left: 30px;}.main-header .main-logo img,.main-header .mobile-menu img {height: 100%;position: absolute;}.main-header .main-logo {top: 50%;margin-top: -0.175px;height: 0.5;}.main-header .mobile-menu {position: absolute;right: 0px;top: 50%;margin-top: -0.15px;height: 0.6;left: auto;right: 30px;}.main-header .mobile-menu img {right: 0px;}.main-header .main-header-content .main-header-company {line-height: 70px;}.main-header .main-header-content .main-header-company .icon,.main-header .main-header-content .main-header-company span {height: 70px;display: inline-block;float: left;height: 70px;}.main-header .main-header-content .main-header-company .icon {margin-right: 10px;}@media screen {.main-header {position: fixed;z-index: 100;top: 0;overflow: hidden;}}.header-comfortable {margin-top: 40px;}.header-comfortable .main-header-logo img {height: 77px;}.header-comfortable .main-header {height: 110px;}.main-footer {margin: 0;color: #7f838a;background: #edeef1;}.main-footer .image-link {display: inline-block;color: #7f838a;margin: 40px 0px;}.main-footer .image-link span,.main-footer .image-link img {display: inline-block;position: relative;height: 24px;}.main-footer .image-link span {margin-right: 10px;}.main-footer .image-link img {vertical-align: -6px;}.main-footer .image-link:hover,.main-footer .image-link:visited {color: #7f838a;}.main-footer p {color: #7f838a;}.main-footer a {color: #579eee;border-bottom: 1px solid #78b1f1;text-decoration: none;}.main-footer a:visited {color: #579eee;}.main-footer a:hover {color: #4e8ed6;}.main-footer a.image-link {border-bottom: none;}.main-footer {position: absolute;bottom: 0;width: 100%;height: 250px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.main-footer-text {text-align: center;padding: 40px 30px;}.main-footer-text p {display: block;max-width: 500px;margin: 0px auto;}.posting-header h2 {margin-top: 0px;}.posting-page .section.page-centered li {margin: 8px 0px 8px 17px;list-style-position: outside;}.posting-page .section.page-centered ul li {list-style-type: disc;}.medium-utility-label,.small-utility-label {color: #808080;font: normal 700 16px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.large-category-label,.medium-category-label,.small-category-label,.button-utility-label {color: #808080;font: normal 700 24px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.medium-category-label,.button-utility-label {font-size: 14px;}.small-utility-label {font-size: 12px;line-height: 1.4;}.large-category-header {font: normal 700 30px/1.4 Lato;letter-spacing: 1px;margin-bottom: 25px;text-transform: uppercase;}.medium-category-label.capitalize-labels {text-transform: capitalize;}.small-category-label {font-size: 12px;line-height: 1.4;}.button-utility-label {text-transform: none;}.vertical-line,.horizontal-line {border-color: #e2e2e2;}.vertical-line {position: absolute;left: 0px;top: 30%;height: 40%;width: 1px;border-left-width: 1px;border-left-style: solid;}.horizontal-line {margin: 20px auto 20px auto;width: 80px;height: 1px;border-bottom-width: 1px;border-bottom-style: solid;}.confirmation-message {text-align: center;}.confirmation-message .template-btn-submit {margin-top: 16px;}.cc-window{opacity:1;-webkit-transition:opacity 1s ease;transition:opacity 1s ease}.cc-window.cc-invisible{opacity:0}.cc-animate.cc-revoke{-webkit-transition:transform 1s ease;-webkit-transition:-webkit-transform 1s ease;transition:-webkit-transform 1s ease;transition:transform 1s ease;transition:transform 1s ease,-webkit-transform 1s ease}.cc-animate.cc-revoke.cc-top{-webkit-transform:translateY(-2em);transform:translateY(-2em)}.cc-animate.cc-revoke.cc-bottom{-webkit-transform:translateY(2em);transform:translateY(2em)}.cc-animate.cc-revoke.cc-active.cc-top{-webkit-transform:translateY(0);transform:translateY(0)}.cc-animate.cc-revoke.cc-active.cc-bottom{-webkit-transform:translateY(0);transform:translateY(0)}.cc-revoke:hover{-webkit-transform:translateY(0);transform:translateY(0)}.cc-grower{max-height:0;overflow:hidden;-webkit-transition:max-height 1s;transition:max-height 1s}.cc-revoke,.cc-window{position:fixed;overflow:hidden;-webkit-box-sizing:border-box;box-sizing:border-box;font-family:Helvetica,Calibri,Arial,sans-serif;font-size:16px;line-height:1.5em;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:nowrap;flex-wrap:nowrap;z-index:9999}.cc-window.cc-static{position:static}.cc-window.cc-floating{padding:2em;max-width:24em;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner{padding:1em 1.8em;width:100%;-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}.cc-revoke{padding:.5em}.cc-revoke:hover{text-decoration:underline}.cc-header{font-size:18px;font-weight:700}.cc-btn,.cc-close,.cc-link,.cc-revoke{cursor:pointer}.cc-link{opacity:.8;display:inline-block;padding:.2em;text-decoration:underline}.cc-link:hover{opacity:1}.cc-link:active,.cc-link:visited{color:initial}.cc-btn{display:block;padding:.4em .8em;font-size:.9em;font-weight:700;border-width:2px;border-style:solid;text-align:center;white-space:nowrap}.cc-highlight .cc-btn:first-child{background-color:transparent;border-color:transparent}.cc-highlight .cc-btn:first-child:focus,.cc-highlight .cc-btn:first-child:hover{background-color:transparent;text-decoration:underline}.cc-close{display:block;position:absolute;top:.5em;right:.5em;font-size:1.6em;opacity:.9;line-height:.75}.cc-close:focus,.cc-close:hover{opacity:1}.cc-revoke.cc-top{top:0;left:3em;border-bottom-left-radius:.5em;border-bottom-right-radius:.5em}.cc-revoke.cc-bottom{bottom:0;left:3em;border-top-left-radius:.5em;border-top-right-radius:.5em}.cc-revoke.cc-left{left:3em;right:unset}.cc-revoke.cc-right{right:3em;left:unset}.cc-top{top:1em}.cc-left{left:1em}.cc-right{right:1em}.cc-bottom{bottom:1em}.cc-floating>.cc-link{margin-bottom:1em}.cc-floating .cc-message{display:block;margin-bottom:1em}.cc-window.cc-floating .cc-compliance{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto}.cc-window.cc-banner{-webkit-box-align:center;-ms-flex-align:center;align-items:center}.cc-banner.cc-top{left:0;right:0;top:0}.cc-banner.cc-bottom{left:0;right:0;bottom:0}.cc-banner .cc-message{display:block;-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto;max-width:100%;margin-right:1em}.cc-compliance{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-ms-flex-line-pack:justify;align-content:space-between}.cc-floating .cc-compliance>.cc-btn{-webkit-box-flex:1;-ms-flex:1;flex:1}.cc-btn+.cc-btn{margin-left:.5em}@media print{.cc-revoke,.cc-window{display:none}}@media screen and (max-width:900px){.cc-btn{white-space:normal}}@media screen and (max-width:414px) and (orientation:portrait),screen and (max-width:736px) and (orientation:landscape){.cc-window.cc-top{top:0}.cc-window.cc-bottom{bottom:0}.cc-window.cc-banner,.cc-window.cc-floating,.cc-window.cc-left,.cc-window.cc-right{left:0;right:0}.cc-window.cc-banner{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner .cc-compliance{-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto}.cc-window.cc-floating{max-width:none}.cc-window .cc-message{margin-bottom:1em}.cc-window.cc-banner{-webkit-box-align:unset;-ms-flex-align:unset;align-items:unset}.cc-window.cc-banner .cc-message{margin-right:0}}.cc-floating.cc-theme-classic{padding:1.2em;border-radius:5px}.cc-floating.cc-type-info.cc-theme-classic .cc-compliance{text-align:center;display:inline;-webkit-box-flex:0;-ms-flex:none;flex:none}.cc-theme-classic .cc-btn{border-radius:5px}.cc-theme-classic .cc-btn:last-child{min-width:140px}.cc-floating.cc-type-info.cc-theme-classic .cc-btn{display:inline-block}.cc-theme-edgeless.cc-window{padding:0}.cc-floating.cc-theme-edgeless .cc-message{margin:2em;margin-bottom:1.5em}.cc-banner.cc-theme-edgeless .cc-btn{margin:0;padding:.8em 1.8em;height:100%}.cc-banner.cc-theme-edgeless .cc-message{margin-left:1em}.cc-floating.cc-theme-edgeless .cc-btn+.cc-btn{margin-left:0}.cc-btn {border-width: 1px;display: inline;font-weight: normal;}.cc-link {color: inherit;}.cc-link:hover {color: #a6daff;}.cc-revoke {display: none;}.cc-window,.cc-revoke {background: #3b3d3f;border-radius: 8px 8px 0 0;color: #d7d7d9;font: inherit;}.cc-window.cc-banner,.cc-window.cc-floating {padding: 16px;}.cc-window.cc-floating {bottom: 0;min-width: 100%;}.cc-window {padding: 16px;}.cc-window .cc-mobile {display: none;}.cc-window .message-inverse {background: #222326;border-radius: 8px 8px 0 0;}.cc-window .momentum-body {margin: -16px;width: calc(100% + 32px);}.cc-window .momentum-body .cookie-banner-link {white-space: nowrap;}.cc-window .momentum-body .message {padding: 16px 16px 16px 48px;}.cc-window .momentum-body .message .icon {font-size: 24px;left: 16px;top: 16px;}.cc-window .message-buttons {margin-right: 16px;margin-top: 12px;}.cc-window h4 {color: #fff;margin-bottom: 4px;}@media screen and (max-width: 1150px) {.cc-window .cc-desktop {display: none;}.cc-window .cc-mobile {display: block;margin-top: 16px;}.cc-window .message {display: flex;}}.error-section {text-align: center;}.error-section img {margin-top: 70px;margin-bottom: 16px;}.application-question input,.application-additional input,.application-question textarea,.application-additional textarea {border-color: #e2e2e2;}.application-question input:active,.application-additional input:active,.application-question textarea:active,.application-additional textarea:active,.application-question input:focus,.application-additional input:focus,.application-question textarea:focus,.application-additional textarea:focus {border-color: #7f838a;}.application-question select,.application-additional select {background: #e2e2e2;border-color: transparent;}.application-question select:hover,.application-additional select:hover {background: #c0c0c0;}.application-question.custom-question,.application-additional.custom-question {display: grid;}.application-question.custom-question .application-label.multiple-choice,.application-additional.custom-question .application-label.multiple-choice,.application-question.custom-question .application-label.multiple-select,.application-additional.custom-question .application-label.multiple-select,.application-question.custom-question .application-label.textarea,.application-additional.custom-question .application-label.textarea,.application-question.custom-question .application-label.dropdown,.application-additional.custom-question .application-label.dropdown {margin-bottom: 0px;}.application-question.custom-question .application-field,.application-additional.custom-question .application-field {display: inline-block;}.application-question.custom-question .application-field input[type=text],.application-additional.custom-question .application-field input[type=text],.application-question.custom-question .application-field input[type=email],.application-additional.custom-question .application-field input[type=email],.application-question.custom-question .application-field input[type=tel],.application-additional.custom-question .application-field input[type=tel] {margin-top: 0px;}.application-question.custom-question .application-field input[type=radio],.application-additional.custom-question .application-field input[type=radio],.application-question.custom-question .application-field input[type=checkbox],.application-additional.custom-question .application-field input[type=checkbox] {left: 0px;}.application-question.custom-question .application-field .upload-file-overlay,.application-additional.custom-question .application-field .upload-file-overlay {margin-bottom: 17.5px;}.application-question.custom-question .application-field ul label,.application-additional.custom-question .application-field ul label {padding-left: 30px;}.application .application-question,.eeo-survey .application-question {list-style-type: none;padding: 0px 0px;}.application .application-label,.eeo-survey .application-label {font-size: 16px;line-height: 1.4;vertical-align: middle;width: 100%;}.application .application-label .description,.eeo-survey .application-label .description {font-size: 12px;margin-bottom: 0;}.application .application-label label,.eeo-survey .application-label label {position: relative;}.application .application-label.multiple-choice,.eeo-survey .application-label.multiple-choice,.application .application-label.multiple-select,.eeo-survey .application-label.multiple-select,.application .application-label.textarea,.eeo-survey .application-label.textarea {vertical-align: top;}.application .application-label.text,.eeo-survey .application-label.text {vertical-align: bottom;}.application .application-field,.eeo-survey .application-field {position: relative;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.application .application-field input[type=text],.eeo-survey .application-field input[type=text],.application .application-field select,.eeo-survey .application-field select,.application .application-field input[type=email],.eeo-survey .application-field input[type=email],.application .application-field input[type=tel],.eeo-survey .application-field input[type=tel] {display: inline-block;width: 100%;}.application .application-field input[type=text][disabled],.eeo-survey .application-field input[type=text][disabled],.application .application-field select[disabled],.eeo-survey .application-field select[disabled],.application .application-field input[type=email][disabled],.eeo-survey .application-field input[type=email][disabled],.application .application-field input[type=tel][disabled],.eeo-survey .application-field input[type=tel][disabled] {background-color: #e2e2e2;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {cursor: pointer;outline: none;}.application .application-field .icon-caret-down,.eeo-survey .application-field .icon-caret-down {height: 16px;width: 16px;position: absolute;right: 10px;margin-top: -8px;top: 50%;}.application .application-field ul,.eeo-survey .application-field ul {list-style-type: none;}.application .application-field label,.eeo-survey .application-field label {padding-left: 40px;position: relative;cursor: pointer;}.application .application-field label .application-answer-alternative,.eeo-survey .application-field label .application-answer-alternative {color: #83868c;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 20px;height: 20px;border-radius: 10px;position: relative;border: 1px solid #e2e2e2;}.application .application-field input[type=radio]:active,.eeo-survey .application-field input[type=radio]:active {background: #ebecf0;}.application .application-field input[type=radio]:checked::after,.eeo-survey .application-field input[type=radio]:checked::after {position: absolute;content: "";height: 20px;width: 20px;left: 0;top: 0;border-radius: 10px;background-color: #00a1dc;}.application .application-field input[type=radio]:checked + span,.eeo-survey .application-field input[type=radio]:checked + span,.application .application-field input[type=checkbox]:checked + span,.eeo-survey .application-field input[type=checkbox]:checked + span {color: #515357;}.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {width: 20px;height: 20px;border: 1px solid #e2e2e2;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-field input[type=checkbox]:active,.eeo-survey .application-field input[type=checkbox]:active {background: #ebecf0;}.application .application-field input[type=checkbox]:checked::after,.eeo-survey .application-field input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: -10%;height: 40%;width: 90%;border-bottom: 4px solid #00a1dc;border-left: 4px solid #00a1dc;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {position: absolute;left: 10px;top: 2px;}.application .application-field .application-university,.eeo-survey .application-field .application-university {position: relative;}.application .application-field .application-university .select2-container,.eeo-survey .application-field .application-university .select2-container {height: 40px;}.application .application-field .application-university .select2-container .select2-selection,.eeo-survey .application-field .application-university .select2-container .select2-selection {padding: 4px 4px 4px 7px;height: 40px;}.application .application-field .application-university .select2-container .select2-selection:active,.eeo-survey .application-field .application-university .select2-container .select2-selection:active,.application .application-field .application-university .select2-container .select2-selection:focus,.eeo-survey .application-field .application-university .select2-container .select2-selection:focus {outline: none;border: 1px solid #7f838a;}.application .application-field .application-university .select2-container .select2-selection span,.eeo-survey .application-field .application-university .select2-container .select2-selection span {font-size: 16px !important;}.application .application-field .application-university .select2-container .select2-selection__arrow,.eeo-survey .application-field .application-university .select2-container .select2-selection__arrow {top: 7px;}.application .application-field .application-dropdown,.eeo-survey .application-field .application-dropdown {position: relative;}.application .application-field .application-dropdown select,.eeo-survey .application-field .application-dropdown select {text-indent: 0.01px;-o-text-overflow: '';text-overflow: '';padding-right: 40px;}.application .application-field .application-dropdown select::-ms-expand,.eeo-survey .application-field .application-dropdown select::-ms-expand {display: none;}.application .application-field .application-dropdown::after,.eeo-survey .application-field .application-dropdown::after {position: absolute;content: "";right: 15px;top: 26px;height: 15px;width: 15px;border-bottom: 1px solid #7f838a;border-left: 1px solid #7f838a;border-color: #72767d;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);pointer-events: none;}.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay {max-width: 100%;padding-left: 41px;}.application .application-field .upload-file-overlay .icon-paperclip,.eeo-survey .application-field .upload-file-overlay .icon-paperclip {position: absolute;left: 15px;}.application .application-field input[type=file],.eeo-survey .application-field input[type=file] {position: absolute;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);top: 0;left: 0;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {font-size: 16px;line-height: 1.4;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {border-radius: 3px;border-width: 1px;border-style: solid;height: 40px;padding: 4px 4px 4px 15px;-webkit-transition: 1px solid #e3e4e6 150ms, background 150ms;-moz-transition: 1px solid #e3e4e6 150ms, background 150ms;-o-transition: 1px solid #e3e4e6 150ms, background 150ms;-ms-transition: 1px solid #e3e4e6 150ms, background 150ms;transition: 1px solid #e3e4e6 150ms, background 150ms;}.application .application-question input[type=text]:active,.eeo-survey .application-question input[type=text]:active,.application .application-additional input[type=text]:active,.eeo-survey .application-additional input[type=text]:active,.application .application-question input[type=email]:active,.eeo-survey .application-question input[type=email]:active,.application .application-additional input[type=email]:active,.eeo-survey .application-additional input[type=email]:active,.application .application-question input[type=tel]:active,.eeo-survey .application-question input[type=tel]:active,.application .application-additional input[type=tel]:active,.eeo-survey .application-additional input[type=tel]:active,.application .application-question textarea:active,.eeo-survey .application-question textarea:active,.application .application-additional textarea:active,.eeo-survey .application-additional textarea:active,.application .application-question select:active,.eeo-survey .application-question select:active,.application .application-additional select:active,.eeo-survey .application-additional select:active,.application .application-question input[type=text]:focus,.eeo-survey .application-question input[type=text]:focus,.application .application-additional input[type=text]:focus,.eeo-survey .application-additional input[type=text]:focus,.application .application-question input[type=email]:focus,.eeo-survey .application-question input[type=email]:focus,.application .application-additional input[type=email]:focus,.eeo-survey .application-additional input[type=email]:focus,.application .application-question input[type=tel]:focus,.eeo-survey .application-question input[type=tel]:focus,.application .application-additional input[type=tel]:focus,.eeo-survey .application-additional input[type=tel]:focus,.application .application-question textarea:focus,.eeo-survey .application-question textarea:focus,.application .application-additional textarea:focus,.eeo-survey .application-additional textarea:focus,.application .application-question select:focus,.eeo-survey .application-question select:focus,.application .application-additional select:focus,.eeo-survey .application-additional select:focus {outline: none;}.application .application-question input.location-input,.eeo-survey .application-question input.location-input,.application .application-additional input.location-input,.eeo-survey .application-additional input.location-input {margin-bottom: 0;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload,.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {width: 230px;height: 40px;}.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .visible-resume-upload .icon,.eeo-survey .application-question .visible-resume-upload .icon,.application .application-additional .visible-resume-upload .icon,.eeo-survey .application-additional .visible-resume-upload .icon {position: absolute;}.application .application-question .visible-resume-upload .resume-upload-name,.eeo-survey .application-question .visible-resume-upload .resume-upload-name,.application .application-additional .visible-resume-upload .resume-upload-name,.eeo-survey .application-additional .visible-resume-upload .resume-upload-name {vertical-align: middle;display: inline-block;line-height: 40px;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;margin-left: 24px;margin-bottom: 3px;}.application .application-question .resume-upload-filename,.eeo-survey .application-question .resume-upload-filename,.application .application-additional .resume-upload-filename,.eeo-survey .application-additional .resume-upload-filename {margin: 8px 0px;display: inline-block;font-size: 14px;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload {position: absolute;top: 0px;left: 0px;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);cursor: pointer;}.application .application-question input.invisible-resume-upload:hover,.eeo-survey .application-question input.invisible-resume-upload:hover,.application .application-additional input.invisible-resume-upload:hover,.eeo-survey .application-additional input.invisible-resume-upload:hover {border-color: #f00;}.application .application-question .linkedin-auth-button,.eeo-survey .application-question .linkedin-auth-button,.application .application-additional .linkedin-auth-button,.eeo-survey .application-additional .linkedin-auth-button {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .linkedin-auth-button.added,.eeo-survey .application-question .linkedin-auth-button.added,.application .application-additional .linkedin-auth-button.added,.eeo-survey .application-additional .linkedin-auth-button.added {background: #dadbdf;}.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea {padding-top: 10px;resize: vertical;width: 100%;height: 130px;}.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-question .dropdown-container,.eeo-survey .application-question .dropdown-container,.application .application-additional .dropdown-container,.eeo-survey .application-additional .dropdown-container {display: none;z-index: 1;overflow-y: auto;position: absolute;max-height: 200px;font-size: 14px;font-family: Meta;letter-spacing: 1px;}.application .application-question .dropdown-loading-results,.eeo-survey .application-question .dropdown-loading-results,.application .application-additional .dropdown-loading-results,.eeo-survey .application-additional .dropdown-loading-results {display: none;}.application .application-question .dropdown-no-results,.eeo-survey .application-question .dropdown-no-results,.application .application-additional .dropdown-no-results,.eeo-survey .application-additional .dropdown-no-results {display: none;}.application .application-question .dropdown-location:hover,.eeo-survey .application-question .dropdown-location:hover,.application .application-additional .dropdown-location:hover,.eeo-survey .application-additional .dropdown-location:hover,.application .application-question .dropdown-location-active,.eeo-survey .application-question .dropdown-location-active,.application .application-additional .dropdown-location-active,.eeo-survey .application-additional .dropdown-location-active {background-color: #000;}.application .required,.eeo-survey .required {display: inline-block;color: #ff794f;margin-left: 4px;font-size: 9px;padding-bottom: 0px;position: absolute;}.application .error-message,.eeo-survey .error-message {background: #ff794f;color: #fff;border-radius: 3px;padding: 5px 15px;width: 700px;max-width: 100%;}.resume-upload-failure,.resume-upload-working,.resume-upload-success,.linkedin-login-success {display: none;cursor: default;position: absolute;top: 0;left: 260px;}.resume-upload-working {cursor: wait;}.resume-upload-success,.linkedin-login-success {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 1s;-webkit-animation-name: fadein;}.resume-upload-failure {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 4s;-webkit-animation-name: fadeout;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);display: none;}.resume-upload-failure .resume-upload-label {color: #ff9000;font-size: 13px;font-weight: bold;line-height: 1.8;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);width: 250px;}.resume-upload-oversize {position: relative;display: none;}.resume-upload-label,.linkedin-login-label {position: absolute;line-height: 40px;display: inline-block;height: 40px;margin-left: 15px;width: 230px;}.loading-indicator {display: inline-block;opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);border-radius: 40px;-webkit-animation: loading 1.5s infinite linear;-moz-animation: loading 1.5s infinite linear;-o-animation: loading 1.5s infinite linear;-ms-animation: loading 1.5s infinite linear;animation: loading 1.5s infinite linear;border: 6px solid #00a1dc;border-top: 6px solid rgba(0,0,0,0);border-left: 6px solid rgba(0,0,0,0);width: 40px;height: 40px;}.loading-indicator.completed {border-left: 6px solid #515357;border-right: 6px solid #515357;border-top: 6px solid #515357;border-bottom: 6px solid #515357;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;text-align: center;}.loading-indicator .icon-checkmark {vertical-align: middle;}.loading-indicator .icon-checkmark >path {fill: #515357;}.application-form h4 {margin: 40px 0;}.awli-button-container {display: inline-block;overflow: hidden;position: relative;vertical-align: middle;}.awli-button-container .iframe-mask {position: absolute;left: 0;background-color: #f9f9f9;z-index: 1;}.awli-button-container .iframe-mask.disclaimer-mask {top: -50px;width: 243px;height: 40px;}.awli-button-container .iframe-mask.button-mask {pointer-events: none;width: 243px;height: 100%;}.awli-button,.awli-button:active,.awli-button:focus {position: relative;margin-right: 15px;padding-left: 41px;padding-right: 0;width: 243px;background: #0073b1;border-color: #0073b1;color: #fff;z-index: 10;outline: none;}.awli-button.button-masked,.awli-button:active.button-masked,.awli-button:focus.button-masked {pointer-events: none;}.awli-button.button-masked > div,.awli-button:active.button-masked > div,.awli-button:focus.button-masked > div {pointer-events: none;}.awli-button.button-masked > div > *,.awli-button:active.button-masked > div > *,.awli-button:focus.button-masked > div > * {pointer-events: none;}.awli-button.state-loading > .loading,.awli-button:active.state-loading > .loading,.awli-button:focus.state-loading > .loading {display: block;}.awli-button.state-loading > .ready,.awli-button:active.state-loading > .ready,.awli-button:focus.state-loading > .ready {display: none;}.awli-button.state-loading > .completed,.awli-button:active.state-loading > .completed,.awli-button:focus.state-loading > .completed {display: none;}.awli-button.state-ready > .loading,.awli-button:active.state-ready > .loading,.awli-button:focus.state-ready > .loading {display: none;}.awli-button.state-ready > .ready,.awli-button:active.state-ready > .ready,.awli-button:focus.state-ready > .ready {display: block;}.awli-button.state-ready > .completed,.awli-button:active.state-ready > .completed,.awli-button:focus.state-ready > .completed {display: none;}.awli-button.state-completed > .loading,.awli-button:active.state-completed > .loading,.awli-button:focus.state-completed > .loading {display: none;}.awli-button.state-completed > .ready,.awli-button:active.state-completed > .ready,.awli-button:focus.state-completed > .ready {display: none;}.awli-button.state-completed > .completed,.awli-button:active.state-completed > .completed,.awli-button:focus.state-completed > .completed {display: block;}.awli-button .icon-checkmark path:first-child,.awli-button:active .icon-checkmark path:first-child,.awli-button:focus .icon-checkmark path:first-child {fill: #fff;}.awli-button .icon-linkedin .icon-li-background,.awli-button:active .icon-linkedin .icon-li-background,.awli-button:focus .icon-linkedin .icon-li-background {fill: currentColor;}.awli-button .icon-linkedin .icon-li-text,.awli-button:active .icon-linkedin .icon-li-text,.awli-button:focus .icon-linkedin .icon-li-text {fill: #0073b1;}.awli-button:hover,.awli-button:active:hover,.awli-button:focus:hover {background: #006299;border-color: #006299;color: #fff;outline: none;}.awli-button:hover.state-loading,.awli-button:active:hover.state-loading,.awli-button:focus:hover.state-loading,.awli-button:hover.state-completed,.awli-button:active:hover.state-completed,.awli-button:focus:hover.state-completed {background: #006299;border-color: #006299;color: #fff;}.awli-button:hover.state-loading .icon-checkmark path:first-child,.awli-button:active:hover.state-loading .icon-checkmark path:first-child,.awli-button:focus:hover.state-loading .icon-checkmark path:first-child,.awli-button:hover.state-completed .icon-checkmark path:first-child,.awli-button:active:hover.state-completed .icon-checkmark path:first-child,.awli-button:focus:hover.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button.state-loading,.awli-button:active.state-loading,.awli-button:focus.state-loading,.awli-button.state-completed,.awli-button:active.state-completed,.awli-button:focus.state-completed {background: #0073b1;border-color: #0073b1;color: #fff;}.awli-button.state-loading .icon-checkmark path:first-child,.awli-button:active.state-loading .icon-checkmark path:first-child,.awli-button:focus.state-loading .icon-checkmark path:first-child,.awli-button.state-completed .icon-checkmark path:first-child,.awli-button:active.state-completed .icon-checkmark path:first-child,.awli-button:focus.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button-label {line-height: 1.33;display: block;overflow: hidden;text-align: left;}.awli-disclaimer {color: #969799;font-size: 12px;line-height: 14px;display: inline-block;padding: 10px 0;margin: 0;vertical-align: middle;}.awli-disclaimer a,.awli-disclaimer a:active,.awli-disclaimer a:focus {color: #707173;}.awli-disclaimer a:hover {color: #969799;}.IN-Awli-widget,.IN-widget {display: inline-block;position: absolute;z-index: 0;}.IN-Awli-widget.IN-Awli-widget,.IN-widget.IN-Awli-widget {left: 2px;top: -37px;}.IN-Awli-widget.IN-widget,.IN-widget.IN-widget {left: 4px;top: 7px;}.h-captcha-spacing {width: 304px;height: 78px;}.consent-required:not(:has(div)):after,.consent-required > div:last-child:after {color: #ff794f;content: '✱';display: inline-block;margin-left: 4px;font-size: 9px;position: absolute;}.eeo-light-text {color: #555659;}h5.eeo-paragraph-heading {font-weight: bold;margin-top: 17.5px;}h5.eeo-paragraph-heading + p {margin-top: 0;}hr {border: 1px solid #e3e4e6;}.application .eeo-option-text.application-answer-alternative {margin-bottom: 0;}.eeo-option-description {color: #555659;font-size: 12px;}.eeo-three-col-list {-webkit-column-width: 233.33333333333334px;-moz-column-width: 233.33333333333334px;column-width: 233.33333333333334px;}.eeo-three-col-list > li {margin-left: 30px;}.eeo-more-info-button {display: inline-block;margin-left: 10px;vertical-align: middle;}.eeo-more-info-button > .icon-info > path {fill: #969799;}.eeo-more-info-button:hover > .icon-info > path {fill: #555659;}.eeo-expandable-description > li {margin-bottom: 10px;}li.select2-results__option.select2-results__option--highlighted .posting-option .posting-tags {color: #fff;}.posting-option {display: block;}.posting-option .posting-tags {display: block;line-height: 1em;font-size: 0.6em;color: #939393;}.posting-option .posting-tag {padding-right: 3px;}.posting-option .posting-title {text-align: left;}@-moz-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@media screen and (min-width: 800px) {.application .application-label,.eeo-survey .application-label,.application .application-field,.eeo-survey .application-field {display: inline-block;}.application .application-label,.eeo-survey .application-label {width: 210px;}.application .application-label.full-width,.eeo-survey .application-label.full-width {width: 100%;}.application .application-field,.eeo-survey .application-field {margin-left: 15px;width: 489px;}.application .application-field.full-width,.eeo-survey .application-field.full-width {padding-left: 0;width: 100%;}}.list .agency-header {font-size: 30px;}.list .agency-sub-header {color: #808080;}.list .postings-list-logo {max-width: 400px;max-height: 50px;}.list .postings-list-logo,.list .postings-list-title {display: inline-block;position: relative;min-height: 50px;float: left;}.list .postings-list-title {margin: 13px 0px 13px 0px;}.list .postings-list-logo {margin-right: 20px;}.list .filter-by-label {margin-right: 16px;}.list .filter-bar {line-height: 40px;max-width: 100%;}.list .filter-bar > div:last-of-type {margin-right: 0;}.list .filter-button-wrapper-margin-right {margin-right: 16px;}.list .filter-button-wrapper {display: inline-block;max-width: 100%;outline: none;position: relative;}.list .filter-button-wrapper:focus .filter-button {border-color: #0c92f3;}.list .filter-button-wrapper:active .filter-button {border-color: #dcdcdc;}.list .filter-button-wrapper .filter-button {color: #555659;max-width: 100%;overflow: hidden;padding: 5px 15px;padding-right: 41px;position: relative;-o-text-overflow: ellipsis;text-overflow: ellipsis;}.list .filter-button-wrapper .filter-button.has-selected-filter {color: #555659;font-weight: bold;}.list .filter-button-wrapper .filter-button .filter-button-caret {position: absolute;left: auto;left: initial;right: 15px;vertical-align: middle;}.list .filter-button-wrapper .filter-button.filter-button-mlp {padding: 8px 16px;width: 173px;font-size: 12px;text-align: left;}.list .filter-popup {position: absolute;top: 110%;left: -1px;border: 1px solid #dcdcdc;border-radius: 3px;display: none;font-size: 14px;line-height: 1;max-height: 300px;overflow-y: hidden;overflow-y: auto;text-align: left;white-space: nowrap;z-index: 1;}.list .filter-popup::-webkit-scrollbar {width: 10px;}.list .filter-popup::-webkit-scrollbar-track {background-color: #fff;}.list .filter-popup::-webkit-scrollbar-track:hover {background-color: #f9f9f9;}.list .filter-popup::-webkit-scrollbar-thumb {background-color: #d7d7d9;border: 1px solid #fff;}.list .filter-popup::-webkit-scrollbar-thumb:hover {background-color: #b1b1b3;border-color: #f9f9f9;}.list .filter-popup ul {list-style-type: none;}.list .filter-popup > ul {background: #fff;padding: 8px 0;}.list .filter-popup .group-link,.list .filter-popup .category-link {display: block;padding: 8px 32px;position: relative;}.list .filter-popup .group-link:hover,.list .filter-popup .category-link:hover {background: #f9f9f9;}.list .filter-popup .group-link:focus,.list .filter-popup .category-link:focus {background: #f3faff;outline: none;}.list .filter-popup .group-link .selected-filter-checkmark,.list .filter-popup .category-link .selected-filter-checkmark {position: absolute;left: 8px;}.list .filter-popup .group-link .selected-filter-checkmark > path,.list .filter-popup .category-link .selected-filter-checkmark > path {fill: #0c92f3;}.list .filter-popup .group-link {font-size: 16px;font-weight: bold;}.list .filter-popup .group-item {border-top: 1px solid #e3e4e6;padding: 8px 0;}.list .filter-popup .group-item:first-of-type {border-top: none;padding-top: 0;}.list .filter-popup .group-item:last-of-type {padding-bottom: 0;}.list .no-postings-message {margin-top: 80px;text-align: center;}.list .postings-group {margin: 40px 0px;}.list .horizontal-line {margin-left: 0px;}.list .posting {display: inline-block;position: relative;width: 100%;margin: 10px 0;}.list .posting .posting-apply {position: absolute;top: 0px;right: 0px;height: 40px;text-align: right;}.list .posting .posting-apply a {min-width: 100px;}.list .posting .posting-title:hover h5 {color: #579eee;}.list .posting .agency-posting-title h5 {margin-right: 230px;}.list .posting .posting-categories {height: 30px;vertical-align: top;}.list .posting .posting-category {display: inline-block;margin-right: 15px;}.show .section p {white-space: pre-wrap;}.show .posting-header {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;}.show .posting-header .posting-headline .posting-category {display: inline-block;margin-right: 10px;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-top: 10px;}@media screen and (min-width: 650px) {.show .posting-header .posting-headline {display: table-cell;width: 100%;}.show .posting-header .postings-btn-wrapper {display: table-cell;vertical-align: top;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-left: 30px;}}@media screen and (max-width: 649px) {.show .posting-header {text-align: center;padding-bottom: 40px;}}@media screen and (max-width: 480px) {.show .postings-btn {width: 100%;}}@media print {.postings-btn {display: none !important;}}.page-centered.section.last-section-apply {text-align: center;margin-bottom: 80px;}.page-centered.section.last-section-apply .btn {display: inline-block;}.page-centered.section.last-section-apply .template-btn-submit {margin: 17.5px 0px;}</style></head><body class="list header-compact"><div class="page list"><div class="main-header page-full-width section-wrapper"><div class="main-header-content page-centered narrow-section page-full-width"><a href="https://jobs.lever.co/GoToGroup" class="main-header-logo"><img alt="GoTo Group logo" src="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1682066441676.png"></a></div></div></div><div class="content-wrapper list-page"><div class="content"><div class="section-wrapper page-full-width"><div class="section page-centered"><div class="filter-bar"><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?workplaceType=onsite" rel="nofollow">On-site</a></li><li><a class="category-link" href="?workplaceType=hybrid" rel="nofollow">Hybrid</a></li><li><a class="category-link" href="?workplaceType=remote" rel="nofollow">Remote</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?location=Bali" rel="nofollow">Bali</a></li><li><a class="category-link" href="?location=Balikpapan" rel="nofollow">Balikpapan</a></li><li><a class="category-link" href="?location=Bengaluru" rel="nofollow">Bengaluru</a></li><li><a class="category-link" href="?location=Bogor" rel="nofollow">Bogor</a></li><li><a class="category-link" href="?location=Depok" rel="nofollow">Depok</a></li><li><a class="category-link" href="?location=Gurugram" rel="nofollow">Gurugram</a></li><li><a class="category-link" href="?location=Ho%20Chi%20Minh%20City" rel="nofollow">Ho Chi Minh City</a></li><li><a class="category-link" href="?location=Jakarta" rel="nofollow">Jakarta</a></li><li><a class="category-link" href="?location=Makassar" rel="nofollow">Makassar</a></li><li><a class="category-link" href="?location=Semarang" rel="nofollow">Semarang</a></li><li><a class="category-link" href="?location=Singapore" rel="nofollow">Singapore</a></li><li><a class="category-link" href="?location=Tangerang" rel="nofollow">Tangerang</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Team: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Team<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li class="group-item"><a class="group-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li class="group-item" role="group" aria-label="FinTech - AML/CFT"><a class="group-link" href="?department=FinTech%20-%20AML%2FCFT" rel="nofollow">FinTech - AML/CFT</a><ul><li><a class="category-link" href="?department=FinTech%20-%20AML%2FCFT&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - CISO"><a class="group-link" href="?department=FinTech%20-%20CISO" rel="nofollow">FinTech - CISO</a><ul><li><a class="category-link" href="?department=FinTech%20-%20CISO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Compliance"><a class="group-link" href="?department=FinTech%20-%20Compliance" rel="nofollow">FinTech - Compliance</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Compliance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Consumer Lending"><a class="group-link" href="?department=FinTech%20-%20Consumer%20Lending" rel="nofollow">FinTech - Consumer Lending</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=Lending%20Operations" rel="nofollow">Lending Operations</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Consumer Payments"><a class="group-link" href="?department=FinTech%20-%20Consumer%20Payments" rel="nofollow">FinTech - Consumer Payments</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Consumer%20Experience" rel="nofollow">Consumer Experience</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Money%20Management" rel="nofollow">Money Management</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Payment%20Core" rel="nofollow">Payment Core</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Crypto"><a class="group-link" href="?department=FinTech%20-%20Crypto" rel="nofollow">FinTech - Crypto</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Crypto&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Data Products &amp; Infra"><a class="group-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra" rel="nofollow">FinTech - Data Products &amp; Infra</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Finance"><a class="group-link" href="?department=FinTech%20-%20Finance" rel="nofollow">FinTech - Finance</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Finance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Merchant Services"><a class="group-link" href="?department=FinTech%20-%20Merchant%20Services" rel="nofollow">FinTech - Merchant Services</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Merchant%20Lending" rel="nofollow">Merchant Lending</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Offline%20Merchants" rel="nofollow">Offline Merchants</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Online%20Merchants" rel="nofollow">Online Merchants</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - CIO"><a class="group-link" href="?department=HoldCo%20-%20CIO" rel="nofollow">HoldCo - CIO</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20CIO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - CISO"><a class="group-link" href="?department=HoldCo%20-%20CISO" rel="nofollow">HoldCo - CISO</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20CISO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - COO Office"><a class="group-link" href="?department=HoldCo%20-%20COO%20Office" rel="nofollow">HoldCo - COO Office</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20COO%20Office&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Corporate Affairs"><a class="group-link" href="?department=HoldCo%20-%20Corporate%20Affairs" rel="nofollow">HoldCo - Corporate Affairs</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Corporate%20Affairs&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=HoldCo%20-%20Corporate%20Affairs&amp;team=Media%20Intelligence" rel="nofollow">Media Intelligence</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Enterprise Risk Management"><a class="group-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management" rel="nofollow">HoldCo - Enterprise Risk Management</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - ESG"><a class="group-link" href="?department=HoldCo%20-%20ESG" rel="nofollow">HoldCo - ESG</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20ESG&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Finance"><a class="group-link" href="?department=HoldCo%20-%20Finance" rel="nofollow">HoldCo - Finance</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Finance&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=HoldCo%20-%20Finance&amp;team=Procurement" rel="nofollow">Procurement</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - People &amp; Culture"><a class="group-link" href="?department=HoldCo%20-%20People%20%26%20Culture" rel="nofollow">HoldCo - People &amp; Culture</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20People%20%26%20Culture&amp;team=HR%20Information%20Systems" rel="nofollow">HR Information Systems</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Ads"><a class="group-link" href="?department=ODS%20-%20Ads" rel="nofollow">ODS - Ads</a><ul><li><a class="category-link" href="?department=ODS%20-%20Ads&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Consumer Platform"><a class="group-link" href="?department=ODS%20-%20Consumer%20Platform" rel="nofollow">ODS - Consumer Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Consumer%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Data Platform"><a class="group-link" href="?department=ODS%20-%20Data%20Platform" rel="nofollow">ODS - Data Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Data%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Engineering Platform"><a class="group-link" href="?department=ODS%20-%20Engineering%20Platform" rel="nofollow">ODS - Engineering Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Engineering%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Food"><a class="group-link" href="?department=ODS%20-%20Food" rel="nofollow">ODS - Food</a><ul><li><a class="category-link" href="?department=ODS%20-%20Food&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Groceries"><a class="group-link" href="?department=ODS%20-%20Groceries" rel="nofollow">ODS - Groceries</a><ul><li><a class="category-link" href="?department=ODS%20-%20Groceries&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Logistics"><a class="group-link" href="?department=ODS%20-%20Logistics" rel="nofollow">ODS - Logistics</a><ul><li><a class="category-link" href="?department=ODS%20-%20Logistics&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Marketplace"><a class="group-link" href="?department=ODS%20-%20Marketplace" rel="nofollow">ODS - Marketplace</a><ul><li><a class="category-link" href="?department=ODS%20-%20Marketplace&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Platform Mobility, Care &amp; Comms"><a class="group-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms" rel="nofollow">ODS - Platform Mobility, Care &amp; Comms</a><ul><li><a class="category-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Public Policy &amp; Government Relations"><a class="group-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations" rel="nofollow">ODS - Public Policy &amp; Government Relations</a><ul><li><a class="category-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Regions"><a class="group-link" href="?department=ODS%20-%20Regions" rel="nofollow">ODS - Regions</a><ul><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Central%20West%20Java%20Regions" rel="nofollow">Central West Java Regions</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=East%20Java%2C%20Bali%2C%20Nusra%20Regions" rel="nofollow">East Java, Bali, Nusra Regions</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Emerging%20Market" rel="nofollow">Emerging Market</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Jabodetabek%20Regions" rel="nofollow">Jabodetabek Regions</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Sales"><a class="group-link" href="?department=ODS%20-%20Sales" rel="nofollow">ODS - Sales</a><ul><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=Sales%20Excellence" rel="nofollow">Sales Excellence</a></li><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=Sales%20Strategy" rel="nofollow">Sales Strategy</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Customer Relationship Management"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management" rel="nofollow">ODS - Shared Service, Customer Relationship Management</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Marketing"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing" rel="nofollow">ODS - Shared Service, Marketing</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Technology"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology" rel="nofollow">ODS - Shared Service, Technology</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport"><a class="group-link" href="?department=ODS%20-%20Transport" rel="nofollow">ODS - Transport</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport &amp; Mobility"><a class="group-link" href="?department=ODS%20-%20Transport%20%26%20Mobility" rel="nofollow">ODS - Transport &amp; Mobility</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport%20%26%20Mobility&amp;team=-" rel="nofollow">-</a></li></ul></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Work type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Work type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?commitment=Direct%20Contract" rel="nofollow">Direct Contract</a></li><li><a class="category-link" href="?commitment=Internship" rel="nofollow">Internship</a></li><li><a class="category-link" href="?commitment=Permanent" rel="nofollow">Permanent</a></li><li><a class="category-link" href="?commitment=" rel="nofollow">Uncategorized</a></li></ul></div></div><noscript><style type="text/css">.filter-button-wrapper:focus {outline: none;}.filter-button-wrapper .filter-popup {top: 100%;}.filter-button-wrapper:focus .filter-popup,.filter-button-wrapper:hover .filter-popup,.filter-button-wrapper:active .filter-popup {display: block;}</style></noscript></div><div class="postings-wrapper"><div class="postings-group"><div class="large-category-header">FinTech - AML/CFT</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f8ec8194-1eb5-4bdb-8419-a57a4966b1c5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5"><h5 data-qa="posting-name">Merchants AML/CFT Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - CISO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="36caef5f-7a1c-4326-80b4-8c146060ac70"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70"><h5 data-qa="posting-name">IT GRC Senior Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Compliance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a9daeacc-5dda-4735-ad7b-db35eb7593a6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6"><h5 data-qa="posting-name">FinServ Compliance Officer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="90d1d8b9-75fb-4211-8d69-99412932f5ba"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba"><h5 data-qa="posting-name">Payments Compliance PPGR Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Consumer Lending</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a3543985-6d2c-45cf-84f7-312ec7efed36"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36"><h5 data-qa="posting-name">Full Stack Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9bc8bd8a-cadc-4942-81c4-193773a294df"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df"><h5 data-qa="posting-name">Growth Analyst - GoPay Later</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6dc20c4e-4d40-4f57-a138-4776013e454e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e"><h5 data-qa="posting-name">Head of Operation - Consumer Lending - #10162</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c9452ba2-cbb3-4ea5-83f7-79e765a67e58"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58"><h5 data-qa="posting-name">Lead Internal Auditor</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0"><h5 data-qa="posting-name">Lead MLOps Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="44117b68-3ece-40ac-91c1-920caadfe5dd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd"><h5 data-qa="posting-name">Principal Data Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="92f4b266-849a-42f2-b7e0-859360a003d8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8"><h5 data-qa="posting-name">Program Manager, Consumer Lending - #10310</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="5611e062-e094-4da3-ab1c-75c85cf62194"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194"><h5 data-qa="posting-name">Risk Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><h5 data-qa="posting-name">Senior Data Analyst (Analytics Engineer)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="472ae629-87cb-4f8c-bb69-eae35cf3751e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e"><h5 data-qa="posting-name">Senior SDET - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d3b7122b-692b-4815-8aa9-f1d0259bccd5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5"><h5 data-qa="posting-name">Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><h5 data-qa="posting-name">Senior Software Engineer (Backend) - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><h5 data-qa="posting-name">Site Reliability Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="88358de8-e37b-4bd6-9afe-359eea3128b9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9"><h5 data-qa="posting-name">Software Engineer (Full Stack) - BNPL</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="afb5bc40-aa4f-4837-a2d9-7d38eade2599"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599"><h5 data-qa="posting-name">Strategy Senior Manager, Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="17408b81-f5a0-4f15-afae-cc04ed7e43b6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6"><h5 data-qa="posting-name">Underwriting and Credit Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Lending Operations</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="0ae5053b-3c5f-432a-9b69-b4cdefb01b79"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79"><h5 data-qa="posting-name">Operation Business Intelligence Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Consumer Payments</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="325ee617-30f3-41c1-a022-6577bd82faf0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0"><h5 data-qa="posting-name">Business Analyst - GoPay</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9a8977f6-ea32-40e0-bb09-d3330c40d056"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056"><h5 data-qa="posting-name">Business Operations Analyst (Trust and Safety) - GoPay - #10311</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da1197ac-dfbc-4ad6-b215-2f2cd4939a0d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d"><h5 data-qa="posting-name">Junior UX Writer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="153e42ca-cf5b-4f43-b09e-58eabda1e5fa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa"><h5 data-qa="posting-name">Senior SDET - Consumer Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Consumer Experience</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="5f86f9c4-80bc-437f-b09c-b61fd85c27eb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb"><h5 data-qa="posting-name">Growth Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="0169bd4d-f352-4162-8e8e-2c09df5b8db4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4"><h5 data-qa="posting-name">SDET - Growth</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Money Management</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8906c3d0-c77f-4a0a-8f25-8b738515ede3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3"><h5 data-qa="posting-name">QA Engineer - Insurance</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bf41d2c6-91b0-4c83-a145-dfcb3ee24b62"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62"><h5 data-qa="posting-name">Savings Growth Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="389c0346-14e0-40e5-85c3-48d830db73b4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4"><h5 data-qa="posting-name">Senior Software Engineer (iOS) - Money Management</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="75c0d634-b28a-4f10-8f5a-efacb32b6444"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444"><h5 data-qa="posting-name">Sr. Software Engineer (Android) - Insurance</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Payment Core</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="076bd021-0157-42a4-89fd-51d9f236e490"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490"><h5 data-qa="posting-name">Senior SDET - Payment Widget &amp; Vendor Gateway</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="96562e50-0bf7-4a14-a910-4ef63f16d451"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451"><h5 data-qa="posting-name">Software Engineer - Android (Consumer Payments)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4439eb62-6f08-444b-946d-1dff07d7d0d3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3"><h5 data-qa="posting-name">Software Engineer - iOS ( Consumer Payments)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Crypto</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="08aa1472-d91f-4c5d-b5e0-e88163943bcd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd"><h5 data-qa="posting-name">Security and System Infra Manager (CISSP) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="fda395d6-457d-4a03-aaa1-33d513c3960b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b"><h5 data-qa="posting-name">Senior Software Engineer (Android) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="769b7391-e6fd-4923-9a92-e060f14e451d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d"><h5 data-qa="posting-name">Senior Software Engineer (Back End) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bcd00ee0-2fb3-43c1-8401-ef184283ccc8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8"><h5 data-qa="posting-name">Senior Software Engineer (Front End) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e6c36118-5d4e-444b-922c-68e03c2ab82e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e"><h5 data-qa="posting-name">Senior Software Engineer (iOS) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Data Products &amp; Infra</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="816f2d4c-5ff6-4e83-8697-9c25df599409"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409"><h5 data-qa="posting-name">Data Scientist Intern</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="0197001e-f39c-4d55-b6b9-1cf247bd17b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0"><h5 data-qa="posting-name">Principal Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="60d37414-287e-4552-a0d0-accf1737d0ce"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce"><h5 data-qa="posting-name">Risk Analyst - Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a61cda6c-82fd-4daf-aabf-3db91e01684f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f"><h5 data-qa="posting-name">Risk Manager - Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><h5 data-qa="posting-name">Senior Data Engineer - Data Streaming</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="a539cdc1-109f-48e8-9b24-1a831b735f01"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01"><h5 data-qa="posting-name">Senior Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="10dbc666-80f8-4250-85ee-59fa92d056aa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa"><h5 data-qa="posting-name">Senior Software Engineer (Data Warehouse)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="449dd201-2d4d-47a0-9cd4-c7ddec91c88e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e"><h5 data-qa="posting-name">Senior Software Engineer (Real-Time Data Streaming)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="60283bc5-9f60-400a-8289-bcbe332fbc09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09"><h5 data-qa="posting-name">Financial Controller Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Merchant Services</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="761415aa-89b7-4ffb-a19b-2b91ac4243b4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4"><h5 data-qa="posting-name">Growth Lead (Merchant Lending)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="70493d8a-7d7f-4660-b1ed-c792d0d765be"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be"><h5 data-qa="posting-name">Head of Sales - Midtrans - #9618</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="3f4f687f-8599-4d5c-96d5-8af234c3b09d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d"><h5 data-qa="posting-name">Onboarding &amp; Support Business Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="fc7c3413-6c4f-42bd-a048-70387bd490a4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4"><h5 data-qa="posting-name">Process Improvement Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><h5 data-qa="posting-name">Sales Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="afd9e752-82f0-4b4f-a4ef-5d86dcce1063"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063"><h5 data-qa="posting-name">Senior Sales Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Merchant Lending</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="dab778da-b4eb-4e7e-bc8e-997af7210d52"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52"><h5 data-qa="posting-name">Software Engineer (Back End) - Merchant Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Offline Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ad8bd932-3494-4181-bd93-282665dce81d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d"><h5 data-qa="posting-name">Internal Trainer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><h5 data-qa="posting-name">Product Design Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="50c8a826-2076-40a3-a829-b96b29c9647f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f"><h5 data-qa="posting-name">Senior Product Marketing Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Online Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="83c662d2-4a1e-40ca-a2d3-daf2a1b102b8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8"><h5 data-qa="posting-name">Product Analyst Intern - Online Merchants</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1a190954-9482-4953-a750-f2ae33a50003"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003"><h5 data-qa="posting-name">Software Engineer Intern - Online Merchants</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - CIO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4cb00240-117e-4ace-a959-fc567e447d5f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f"><h5 data-qa="posting-name">IT Finance Project Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="099498bc-c171-4505-97d7-3a432d302e14"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14"><h5 data-qa="posting-name">Senior SAP Technical</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - CISO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="178ba514-705f-4f0b-9e48-fe917c47a95b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b"><h5 data-qa="posting-name">Enterprise Information Security Engineer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9a7a6e83-9532-48a6-b1b1-b7a1350b4f12"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12"><h5 data-qa="posting-name">Security Engineering Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="767d8980-5402-488d-b62c-222c0b4a0bfc"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc"><h5 data-qa="posting-name">Senior Cyber Threat Intelligence Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - COO Office</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="2242125a-7155-4353-bc79-473d237d6808"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808"><h5 data-qa="posting-name">Business Intelligence Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="73e71b86-d53f-4841-92ec-4bd09a0ef479"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479"><h5 data-qa="posting-name">Data Engineer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="36d71dff-c9ac-44b8-b870-f74d941bd7d3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3"><h5 data-qa="posting-name">Data Engineer Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6d8ebb73-2348-423d-847e-b8a8408ac1ed"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed"><h5 data-qa="posting-name">Senior Data Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Corporate Affairs</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="fc5f2c90-038e-4c53-9971-2ae72f680c03"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03"><h5 data-qa="posting-name">International &amp; Singapore Communications Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Media Intelligence</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a3de3e96-fc51-46e4-bcd4-f012f0d03bdb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb"><h5 data-qa="posting-name">Media Intelligence Intern</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Enterprise Risk Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><h5 data-qa="posting-name">Head of Business Continuity Management</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9c0a73a5-09ce-4b06-8527-9415ef3d393c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c"><h5 data-qa="posting-name">Internal Audit Senior Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - ESG</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="1a303596-73f9-4d05-85f9-73cd361f03ef"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef"><h5 data-qa="posting-name">Sustainability Senior Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="56966262-038f-497f-84c1-f360a9440c55"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55"><h5 data-qa="posting-name">Assistant Tax Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Procurement</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274"><h5 data-qa="posting-name">Procurement Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - People &amp; Culture</div><div class="posting-category-title large-category-label">HR Information Systems</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8fe35112-8410-4cf3-9a50-4c7287e95b57"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57"><h5 data-qa="posting-name">People Systems Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta / Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Ads</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="94f85d13-6fe6-43a8-96c8-4898ab75d908"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908"><h5 data-qa="posting-name">Ads Ops Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="eaab5bee-084d-4cdc-bd08-63230251009c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c"><h5 data-qa="posting-name">Supply Strategy Data Analyst [Ads]</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Consumer Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ab96f280-f1d6-4ff7-bbe8-198ee4168bb4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4"><h5 data-qa="posting-name">Market Intelligence (Data Engineer)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="976d0171-5a06-43e2-9ec6-e0b45345c6fd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd"><h5 data-qa="posting-name">Senior Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="86673189-b5e2-4ace-b1a3-5ab20f14d84d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d"><h5 data-qa="posting-name">Senior Data Scientist (India)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="cd554abc-dc06-4177-be50-ccbc638fd6d9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9"><h5 data-qa="posting-name">Software Engineer - Customer Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Data Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="e6583aa0-7097-4e6f-9f91-7f24d5441156"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156"><h5 data-qa="posting-name">Senior Product Manager, Data Science Platform and Data Products</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta / Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Engineering Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="dfe98505-36d8-4467-aa36-df8599ab69d8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8"><h5 data-qa="posting-name">Engineering Manager - Data Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><h5 data-qa="posting-name">Fullstack Engineer - Engineering Platforms</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a593bf17-baf2-479e-8154-c69d6a7d4f09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09"><h5 data-qa="posting-name">Lead Software Engineer - Engineering Platforms</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><h5 data-qa="posting-name">Lead Software Engineer - Observability</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="6f2d563a-182c-4c23-8c72-9d2a4f563ed9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9"><h5 data-qa="posting-name">Principal Engineer - Cloud Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru / Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="7c3c43e3-8b8d-48a4-a590-7754207b2d1b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b"><h5 data-qa="posting-name">Principal Software Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><h5 data-qa="posting-name">Senior Android Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><h5 data-qa="posting-name">Senior Data Warehouse Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2b430ba4-210e-4db6-a63e-c11459a0304f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f"><h5 data-qa="posting-name">Senior Data Warehouse Engineer - India</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><h5 data-qa="posting-name">Senior Database Administrator Engineer - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="28fe323b-ed5f-482b-b71d-ed60662bed8b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b"><h5 data-qa="posting-name">Senior DevOps Engineer - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="68f907a3-329f-411b-af2d-a66b38243919"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919"><h5 data-qa="posting-name">Senior Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8afd4278-a5a8-43f2-8718-2986433f2ddb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb"><h5 data-qa="posting-name">Senior Technical Program Manager - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3"><h5 data-qa="posting-name">Technical Program Manager - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Food</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="657d7112-420a-4e42-8bfd-1b790fc05155"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155"><h5 data-qa="posting-name">#10357 Senior Software Engineer - Go-food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><h5 data-qa="posting-name">Growth Planning &amp; Operation - GoFood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><h5 data-qa="posting-name">Growth Strategy Manager - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2d3aae20-ff7e-4afb-8164-a351661c1680"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680"><h5 data-qa="posting-name">Lead Software Engineer (IC) - Go-Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="e407433b-435a-4607-89bd-5faf51cf622e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e"><h5 data-qa="posting-name">Product Designer - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><h5 data-qa="posting-name">Product Manager - Growth</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da8d4a37-f5a4-4436-8743-58c787781285"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285"><h5 data-qa="posting-name">Senior Growth Manager - Food &amp; Ads</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="57bb5e7f-9ea0-462f-ac36-5717b49d0380"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380"><h5 data-qa="posting-name">Senior Software Engineer - Go-food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="930cfb6b-99e3-4334-bc10-3fac18f8eff0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0"><h5 data-qa="posting-name">Software Engineer (Android) - Gofood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Groceries</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="87b4d0e4-219e-4ba7-9433-27220623ab69"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69"><h5 data-qa="posting-name">#10358 Software Engineer - Backend (Groceries)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="03e3c5dd-2c14-4737-820e-f32b6cccf632"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632"><h5 data-qa="posting-name">Operations Manager - GoMart</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="49388333-1938-4c06-b453-911eee08c53f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f"><h5 data-qa="posting-name">Pricing &amp; Supply Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663"><h5 data-qa="posting-name">User Growth Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Logistics</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f53cae40-f605-4215-9a82-b48c5db508b5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5"><h5 data-qa="posting-name">#10010 Senior Backend Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="ce351965-e2f9-4f8f-8cad-38fb4cd045e9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9"><h5 data-qa="posting-name">#10279 Senior Android Developer (Logistic)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958"><h5 data-qa="posting-name">#10359 Software Engineer - Backend</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="180b3e9e-cfb9-471d-8c30-410aef031535"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535"><h5 data-qa="posting-name">Software Engineer  - Logistic</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Marketplace</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8d7ae844-168c-4e78-843a-94aceb7b1a66"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66"><h5 data-qa="posting-name">Senior Software Engineer  - Marketplace</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Platform Mobility, Care &amp; Comms</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><h5 data-qa="posting-name">Product Manager - Logistic</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="34f6146a-c482-407c-a31c-72ac9bb90a7c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c"><h5 data-qa="posting-name">Senior Data Scientist - Marketplace (Singapore)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Public Policy &amp; Government Relations</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><h5 data-qa="posting-name">Manager of Food &amp; Groceries Regulatory</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bf9ad9be-9cca-41e0-9c6d-a6b66e91726b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b"><h5 data-qa="posting-name">Transport and Mobility PPGR Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Regions</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb"><h5 data-qa="posting-name">Area Operations Manager - Bekasi</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><h5 data-qa="posting-name">Area Operations Manager (Bogor Depok)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Depok / Bogor</span></div></a></div><div class="posting" data-qa-posting-id="8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><h5 data-qa="posting-name">Area Operations Staff</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="719f7a78-460a-4496-9298-ca57b835b120"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120"><h5 data-qa="posting-name">Operation Support Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4ba1eea8-feed-4843-be2e-93a21f0eadb1"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1"><h5 data-qa="posting-name">Region Analytics Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div><div class="posting" data-qa-posting-id="3377f50a-d56f-42e0-acc5-b69d405a37a9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9"><h5 data-qa="posting-name">Senior/Partnership Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Central West Java Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f1bdce17-4ab5-49ab-9dbc-6d96a5619846"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846"><h5 data-qa="posting-name">Area CE Associate - Semarang - #10227</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Semarang</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">East Java, Bali, Nusra Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="73172a46-5486-4860-a256-8e17225c4a47"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47"><h5 data-qa="posting-name">Account Executive (Bali)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Bali</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Emerging Market</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="95ee9a06-a46d-43a2-a8e7-003de776404d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d"><h5 data-qa="posting-name">Area Operations Supervisor - Balikpapan</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Balikpapan</span></div></a></div><div class="posting" data-qa-posting-id="20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450"><h5 data-qa="posting-name">Area Sales Support Supervisor (Sulampa)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Makassar</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Jabodetabek Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="94efd0c8-e79b-41e1-aa37-a7a4c08c108f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f"><h5 data-qa="posting-name">Account Executive (Tangerang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="885b2af9-c94a-4010-b0c4-c6ea7812039b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b"><h5 data-qa="posting-name">Account Executive (Tangerang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Sales</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a007af4b-690d-4487-874d-f04ce3f62ce0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0"><h5 data-qa="posting-name">Unmanaged Merchant Engagement Senior Associate - #10326</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Sales Excellence</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f39be622-e287-41df-bcb2-7389478a1be4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4"><h5 data-qa="posting-name">Sales Support Senior Associate, Enterprise</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Sales Strategy</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6"><h5 data-qa="posting-name">Head of Sales Strategy - #10056</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Customer Relationship Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="0489939a-c571-4d5f-adaa-95ceac8912c5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5"><h5 data-qa="posting-name">Region Operations Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><h5 data-qa="posting-name">Strategic Planner - Creative Labs - #10088</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Marketing</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="7d1c915f-ac53-4a2c-887a-41bbbda48a26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26"><h5 data-qa="posting-name">Graphic Designer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><h5 data-qa="posting-name">Social Media Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Technology</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4a126665-42d6-4a36-82a5-089dca789f41"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41"><h5 data-qa="posting-name">Lead Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="426f18b4-739e-4da0-a74b-446c349c0a31"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31"><h5 data-qa="posting-name">Principal Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="376aefd9-6d6c-4e57-8040-a3b0dd416d26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><h5 data-qa="posting-name">Senior SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="331177df-4294-4bc1-93a4-6459ff18ef97"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97"><h5 data-qa="posting-name">Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e2bbb29c-85ef-4db2-9ea7-93af9101b634"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634"><h5 data-qa="posting-name">Sr. Software Engineer (iOS) - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru / Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="d93a7524-8ab9-4499-9f04-0876fcafa529"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529"><h5 data-qa="posting-name">Data Operations Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="5d07cd21-8826-4de7-9ad4-15909a0c5c37"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37"><h5 data-qa="posting-name">Digital Marketing Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="eb38692a-8133-4cd2-a793-f5d75ee8841a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a"><h5 data-qa="posting-name">Driver Care Lead, Hub Operations</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="1a011faf-f8c7-4531-b2ed-c3837dd521f0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1a011faf-f8c7-4531-b2ed-c3837dd521f0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1a011faf-f8c7-4531-b2ed-c3837dd521f0"><h5 data-qa="posting-name">GoCorp Sales Senior Manager (Enterprise &amp; SMB)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c838dc08-24e8-417c-9d70-a617bc58e200"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200"><h5 data-qa="posting-name">Head of Engineering - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="43e7dcf0-4b25-486e-b366-e2311bcb0335"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/43e7dcf0-4b25-486e-b366-e2311bcb0335" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/43e7dcf0-4b25-486e-b366-e2311bcb0335"><h5 data-qa="posting-name">Head of GoCorp Strategy &amp; Planning</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f1d481f6-4e2d-401b-b310-fca641ab29d4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4"><h5 data-qa="posting-name">Lead - iOS (Transport)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="9e0d8fd7-d416-49ee-8c0a-fcad22c923b7"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7"><h5 data-qa="posting-name">Lead Software Engineer - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="967cfe0a-0243-4a2d-8813-038c355e43c3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3"><h5 data-qa="posting-name">Marketing Planning Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6f3368c9-6e84-489c-add3-4ad1fd4b9519"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519"><h5 data-qa="posting-name">Operations Analyst, Data Operations (Trust &amp; Safety)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="0911a6fe-475a-498f-bf48-7d492e3d04d2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2"><h5 data-qa="posting-name">Pricing &amp; Supply Senior Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="20554643-fae8-4082-8797-7d5fd44db8b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0"><h5 data-qa="posting-name">Project Manager - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><h5 data-qa="posting-name">Risk Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="53c0b8a9-1a83-4c34-9a59-b5170ce54193"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193"><h5 data-qa="posting-name">Senior Software Engineer - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c0e92e19-ce60-4cfc-a58b-553f17452483"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483"><h5 data-qa="posting-name">Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="89a62415-b145-4593-ac20-b82ec0ccfacb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb"><h5 data-qa="posting-name">Software Engineer (iOS) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="22ac4805-bcbe-4698-9e51-cb25754ac244"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244"><h5 data-qa="posting-name">Sr. Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport &amp; Mobility</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8bf17375-6318-400f-8216-4a132071777a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a"><h5 data-qa="posting-name">Lead Product Manager, GoCorp</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div></div></div></div></div></div><div class="main-footer page-full-width"><div class="main-footer-text page-centered"><p><a href="https://www.gotocompany.com/">GoTo Group Home Page</a></p><a href="https://www.lever.co/job-seeker-support/" class="image-link"><span>Jobs powered by </span><img alt="Lever logo" src="/img/lever-logo-full.svg"></a></div></div><script src="/js/bug-snag.js" data-apikey="6a247c6ff13012d02fde17377f0b857b" data-appversion="0.0.1721278246" data-endpoint="https://bugs.lever.co/js" data-releasestage="production"></script><script>var gaCode = "UA-129682534-1";</script><script>var gaAllowLinker = false;</script><script async src="https://www.googletagmanager.com/gtag/js?id=UA-129682534-1"></script><script>if (gaCode.startsWith('UA')) {window.initializeGoogleAnalytics = function() {(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,'script','//www.google-analytics.com/analytics.js','ga');ga('create', gaCode, {name: "customer",allowLinker: gaAllowLinker,});ga('customer.send', 'pageview');}} else {window.initializeGoogleAnalytics = function() {window.dataLayer = window.dataLayer || [];function gtag(){dataLayer.push(arguments);}gtag('js', new Date());gtag('config', gaCode);if (gaAllowLinker) {gtag('set', 'linker', 'lever.co');}}}</script><script type="text/javascript">/*We only want to not initialize Google Analytics and Segment on load if the following is true:- `gdpr` is enabled for the account- the account has the `cookieBanner` enabled- the account has the `optIn` cookieBanner typeThis is the only case where an applicant has to explicitly opt-in to the cookie consent before we can load GA/Segment*//* 2022-03-08: Disabling segment tracking due to an explosion in MAU after removing identify call */window.initializeGoogleAnalytics();window.hasInitializedAnalytics = true;</script></body></html><script src="/js/jquery-3.6.1.min.js"></script><script src="/js/list.js"></script>
-  recorded_at: Mon, 29 Jul 2024 09:06:45 GMT
+        <!DOCTYPE html><html><head prefix="og: http://ogp.me/ns#"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>GoTo Group</title><style>.template-btn-submit.hex-color {background: #00CC33;border-color: #00c230;color: white;}.template-btn-submit.hex-color:visited {color: white;}.template-btn-submit.hex-color:hover {background: #00c230;color: white;}.template-btn-submit.hex-color:active,.template-btn-submit.hex-color:focus {background: #008f24;color: white;}</style><meta name="twitter:card" value="summary"><meta name="twitter:title" content="GoTo Group"><meta name="twitter:description" content="Job openings at GoTo Group"><meta name="twitter:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733905611.png"><meta property="og:title" content="GoTo Group jobs" /><meta property="og:description" content="Job openings at GoTo Group" /><meta property="og:url" content="https://jobs.lever.co/GoToGroup" /><meta property="og:image" content="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1707733917014.png" /><meta property="og:image:height" content="630" /><meta property="og:image:width" content="1200" /><style>@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metaboldlf-webfont-2017.woff") format('woff');font-weight: 600;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormal-webfont-2017.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metanormalitaliclf-webfont-2017.woff") format('woff');font-weight: 400;font-style: italic;}@font-face {font-family: 'Meta';src: url("https://cdn.lever.co/fonts/Meta/metabolditaliclf-webfont-2017.woff") format('woff');font-weight: 600;font-style: italic;}@font-face {font-family: 'Meta-Caps';src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.eot");src: url("https://cdn.lever.co/fonts/Meta/MetaScWeb-Normal.woff") format('woff');font-weight: 400;font-style: normal;}@font-face {font-family: 'Avenir';src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.eot");src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Avenir/Avenir-Next-Pro-Regular.ttf") format('truetype');font-weight: normal;font-style: normal;}.caps-label,.classic-table th,h4,h6,th,.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.toggle-label,.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before,.cc-btn {font: 14px/1.4em 'Meta-Caps', sans-serif;text-transform: lowercase;letter-spacing: 1px;}.label,body,input,select,textarea,.btn-no-style,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {font: 400 14px/1.4em Meta, sans-serif;text-transform: none;letter-spacing: 0;}p.larger,.large-input,.large-input.dark,.message-banner {font: 400 16px/1.4em Meta, sans-serif;}h1,h2,h3,h5 {font: 600 16px/1.4em Meta, sans-serif;-webkit-font-smoothing: antialiased;}h1,h2,h3,h5 {color: #222326;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;top: 0;bottom: 0;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {position: absolute;right: 0;left: 0;}.hidden {display: none !important;}.fadein {-webkit-animation: lever-fadein 300ms ease-in;-moz-animation: lever-fadein 300ms ease-in;-o-animation: lever-fadein 300ms ease-in;-ms-animation: lever-fadein 300ms ease-in;animation: lever-fadein 300ms ease-in;opacity: 1;-ms-filter: none;filter: none;}.fadeout {-webkit-animation: lever-fadeout 300ms ease-in;-moz-animation: lever-fadeout 300ms ease-in;-o-animation: lever-fadeout 300ms ease-in;-ms-animation: lever-fadeout 300ms ease-in;animation: lever-fadeout 300ms ease-in;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.slidedown {-webkit-animation: lever-slidedown 300ms ease-in;-moz-animation: lever-slidedown 300ms ease-in;-o-animation: lever-slidedown 300ms ease-in;-ms-animation: lever-slidedown 300ms ease-in;animation: lever-slidedown 300ms ease-in;}.slideup {-webkit-animation: lever-slideup 300ms ease-out;-moz-animation: lever-slideup 300ms ease-out;-o-animation: lever-slideup 300ms ease-out;-ms-animation: lever-slideup 300ms ease-out;animation: lever-slideup 300ms ease-out;}.face-off {background-color: #f0f;}.face-off-border {border-color: #f0f !important;}.face-off-label {display: block;position: absolute;top: 24px;font-size: 24px;width: 100%;text-align: center;color: #fff;}.comma-separated:after {content: ", ";}.comma-separated:last-of-type:after {content: "";}.numbers,.dates,.count {font-family: 'Avenir';font-size: 0.857em;}.numbers,.dates {font-size: 0.92em;text-transform: uppercase;}.label {font-size: 12px;color: #969799;}.label.dark {color: #6a7c83;}.caps-label,.classic-table th {font-size: 12px;color: #969799;}.caps-label.dark,.classic-table th.dark {color: #6a7c83;}.vert-space-1 {margin-top: 5px;}.vert-space-2 {margin-top: 10px;}.vert-space-3 {margin-top: 15px;}.vert-space-4 {margin-top: 20px;}.vert-space-5 {margin-top: 25px;}.vert-space-6 {margin-top: 30px;}.vert-space-7 {margin-top: 35px;}.vert-space-8 {margin-top: 40px;}.vert-space-9 {margin-top: 45px;}.vert-space-10 {margin-top: 50px;}.vert-space-11 {margin-top: 55px;}.vert-space-12 {margin-top: 60px;}.full-width {width: 100%;}.left-align {text-align: left;}.right-align {text-align: right;}.centered {text-align: center;}.bulleted-list,.numbered-list {margin-left: 15px;}.bulleted-list li,.numbered-list li {margin-bottom: 8px;}.classic-table.fixed {table-layout: fixed;}.classic-table.no-padding td,.classic-table.no-padding th {padding: initial;}.classic-table.dark td,.classic-table.dark th {border-bottom: 1px solid #536266;}.classic-table.dark th {color: #6a7c83;}.classic-table td,.classic-table th {border-bottom: 1px solid #e3e4e6;padding: 10px 15px;vertical-align: top;}.classic-table td:first-of-type,.classic-table th:first-of-type {padding-left: 0;}.classic-table.no-bottom-border tr:last-child > td,.classic-table.no-bottom-border tr:last-child > th {border-bottom: none;}@-moz-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes lever-fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slidedown {0% {-webkit-transform: translateY(-20px);-moz-transform: translateY(-20px);-o-transform: translateY(-20px);-ms-transform: translateY(-20px);transform: translateY(-20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}@keyframes lever-slideup {0% {-webkit-transform: translateY(20px);-moz-transform: translateY(20px);-o-transform: translateY(20px);-ms-transform: translateY(20px);transform: translateY(20px);opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {-webkit-transform: translateY(0px);-moz-transform: translateY(0px);-o-transform: translateY(0px);-ms-transform: translateY(0px);transform: translateY(0px);opacity: 1;-ms-filter: none;filter: none;}}* {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}body {background: #f9f9f9;color: #555659;}th {text-align: left;}body,dd,dl,dt,fieldset,form,h1,h2,h3,h4,h5,h6,li,menu,ol,p,td,th,ul,.toggle-label,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;}ul {margin: 0 auto;}table {border-collapse: collapse;border-spacing: 0;}fieldset,img {border: 0;}img.desaturate {-webkit-filter: grayscale(100%);}h1 {font-size: 36px;}h2,h5 {font-size: 24px;}h3 {font-size: 18px;}h5 {font-size: 16px;}h6,th {font-size: 12px;}a,a:visited {color: #579eee;text-decoration: none;}a:hover {color: #555659;cursor: pointer;}a:active {color: #0c92f3;}p>a {text-decoration: underline;color: inherit;}b {font-weight: 600;-webkit-font-smoothing: antialiased;}input,select,textarea {color: #555659;margin: 0;}input,select {height: 30px;}section {padding-bottom: 16px;}button {-webkit-appearance: button;-moz-appearance: button;appearance: button;cursor: pointer;}.btn,.submit,.btn-large,.submit-large,.btn-large-secondary,.dark-button,.cc-btn {position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 5px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;color: #555659;background: #fcfcfc;background: -webkit-linear-gradient(top, #fff, #f9f9f9);background: -moz-linear-gradient(top, #fff, #f9f9f9);background: -o-linear-gradient(top, #fff, #f9f9f9);background: -ms-linear-gradient(top, #fff, #f9f9f9);background: linear-gradient(to bottom, #fff, #f9f9f9);-webkit-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-moz-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-o-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;-ms-transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;transition: background 0.15s, border-color 0.15s, color 0.15s, box-shadow 0.15s, fill 0.15s;}.btn:hover,.submit:hover,.btn-large:hover,.submit-large:hover,.btn-large-secondary:hover,.dark-button:hover,.cc-btn:hover,.btn-invisible:hover,.btn-no-style:hover {color: #1a1b1c;border-color: #969799;}.btn:active,.submit:active,.btn-large:active,.submit-large:active,.btn-large-secondary:active,.dark-button:active,.cc-btn:active {border-color: #555659;background: -webkit-linear-gradient(top, #f9f9f9, #fff);background: -moz-linear-gradient(top, #f9f9f9, #fff);background: -o-linear-gradient(top, #f9f9f9, #fff);background: -ms-linear-gradient(top, #f9f9f9, #fff);background: linear-gradient(to bottom, #f9f9f9, #fff);}.btn:active .icon >path,.submit:active .icon >path,.btn-large:active .icon >path,.submit-large:active .icon >path,.btn-large-secondary:active .icon >path,.dark-button:active .icon >path,.cc-btn:active .icon >path {fill: #555659;}.btn:focus,.submit:focus,.btn-large:focus,.submit-large:focus,.btn-large-secondary:focus,.dark-button:focus,.cc-btn:focus {outline: thin dotted;outline: 3px auto #0c92f3;outline-offset: -2px;}.btn.disabled,.submit.disabled,.btn-large.disabled,.submit-large.disabled,.btn-large-secondary.disabled,.dark-button.disabled,.cc-btn.disabled,.btn:disabled,.submit:disabled,.btn-large:disabled,.submit-large:disabled,.btn-large-secondary:disabled,.dark-button:disabled,.cc-btn:disabled,input.btn:disabled {cursor: default;pointer-events: none;-webkit-box-shadow: none;box-shadow: none;background: #e3e4e6;color: #555659;border-color: #dcdcdc;outline: none;}.btn.disabled.has-tip,.submit.disabled.has-tip,.btn-large.disabled.has-tip,.submit-large.disabled.has-tip,.btn-large-secondary.disabled.has-tip,.dark-button.disabled.has-tip,.cc-btn.disabled.has-tip,.btn:disabled.has-tip,.submit:disabled.has-tip,.btn-large:disabled.has-tip,.submit-large:disabled.has-tip,.btn-large-secondary:disabled.has-tip,.dark-button:disabled.has-tip,.cc-btn:disabled.has-tip,input.btn:disabled.has-tip {pointer-events: auto;}.btn.disabled:hover,.submit.disabled:hover,.btn-large.disabled:hover,.submit-large.disabled:hover,.btn-large-secondary.disabled:hover,.dark-button.disabled:hover,.cc-btn.disabled:hover,.btn:disabled:hover,.submit:disabled:hover,.btn-large:disabled:hover,.submit-large:disabled:hover,.btn-large-secondary:disabled:hover,.dark-button:disabled:hover,.cc-btn:disabled:hover,input.btn:disabled:hover,.btn.disabled:active,.submit.disabled:active,.btn-large.disabled:active,.submit-large.disabled:active,.btn-large-secondary.disabled:active,.dark-button.disabled:active,.cc-btn.disabled:active,.btn:disabled:active,.submit:disabled:active,.btn-large:disabled:active,.submit-large:disabled:active,.btn-large-secondary:disabled:active,.dark-button:disabled:active,.cc-btn:disabled:active,input.btn:disabled:active {color: #555659;background: #e3e4e6;border-color: #dcdcdc;}.btn.dropdown-button,.submit.dropdown-button,.btn-large.dropdown-button,.submit-large.dropdown-button,.btn-large-secondary.dropdown-button,.dark-button.dropdown-button,.cc-btn.dropdown-button {text-align: left;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;padding-right: 19px;}.btn.dropdown-button.full-width,.submit.dropdown-button.full-width,.btn-large.dropdown-button.full-width,.submit-large.dropdown-button.full-width,.btn-large-secondary.dropdown-button.full-width,.dark-button.dropdown-button.full-width,.cc-btn.dropdown-button.full-width {width: 100%;}.btn .icon >path,.submit .icon >path,.btn-large .icon >path,.submit-large .icon >path,.btn-large-secondary .icon >path,.dark-button .icon >path,.cc-btn .icon >path {fill: #555659;}.btn.has-icon,.submit.has-icon,.btn-large.has-icon,.submit-large.has-icon,.btn-large-secondary.has-icon,.dark-button.has-icon,.cc-btn.has-icon {padding-left: 41px;}.btn.has-icon .icon,.submit.has-icon .icon,.btn-large.has-icon .icon,.submit-large.has-icon .icon,.btn-large-secondary.has-icon .icon,.dark-button.has-icon .icon,.cc-btn.has-icon .icon,.btn.has-icon .loading-indicator,.submit.has-icon .loading-indicator,.btn-large.has-icon .loading-indicator,.submit-large.has-icon .loading-indicator,.btn-large-secondary.has-icon .loading-indicator,.dark-button.has-icon .loading-indicator,.cc-btn.has-icon .loading-indicator {position: absolute;left: 15px;top: calc(50% - 8px);}.btn.has-icon .btn-content,.submit.has-icon .btn-content,.btn-large.has-icon .btn-content,.submit-large.has-icon .btn-content,.btn-large-secondary.has-icon .btn-content,.dark-button.has-icon .btn-content,.cc-btn.has-icon .btn-content {position: relative;display: inline-block;}.btn.has-icon .btn-content .icon,.submit.has-icon .btn-content .icon,.btn-large.has-icon .btn-content .icon,.submit-large.has-icon .btn-content .icon,.btn-large-secondary.has-icon .btn-content .icon,.dark-button.has-icon .btn-content .icon,.cc-btn.has-icon .btn-content .icon,.btn.has-icon .btn-content .loading-indicator,.submit.has-icon .btn-content .loading-indicator,.btn-large.has-icon .btn-content .loading-indicator,.submit-large.has-icon .btn-content .loading-indicator,.btn-large-secondary.has-icon .btn-content .loading-indicator,.dark-button.has-icon .btn-content .loading-indicator,.cc-btn.has-icon .btn-content .loading-indicator {left: -26px;}.btn.has-icon.right,.submit.has-icon.right,.btn-large.has-icon.right,.submit-large.has-icon.right,.btn-large-secondary.has-icon.right,.dark-button.has-icon.right,.cc-btn.has-icon.right {padding-left: 15px;padding-right: 41px;}.btn.has-icon.right .icon,.submit.has-icon.right .icon,.btn-large.has-icon.right .icon,.submit-large.has-icon.right .icon,.btn-large-secondary.has-icon.right .icon,.dark-button.has-icon.right .icon,.cc-btn.has-icon.right .icon {right: 15px;left: initial;}.btn small,.submit small,.btn-large small,.submit-large small,.btn-large-secondary small,.dark-button small,.cc-btn small {margin-left: 10px;font-size: 12px;opacity: 0.67;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=67)";filter: alpha(opacity=67);}.btn small.dates,.submit small.dates,.btn-large small.dates,.submit-large small.dates,.btn-large-secondary small.dates,.dark-button small.dates,.cc-btn small.dates {font-size: 11px;}.submit,.submit-large {color: #fff;background: #0c92f3;border: 1px solid #0c92f3;}.submit .icon >path,.submit-large .icon >path {fill: #fff;}.submit:hover,.submit-large:hover {color: #fff;background: #007fd9;border: 1px solid #0c92f3;}.submit:active,.submit-large:active {background: #1a1b1c;border-color: #1a1b1c;}.submit:active .icon >path,.submit-large:active .icon >path {fill: #fff;}.submit:focus,.submit-large:focus {outline-color: #064979;}.btn-large,.btn-large-secondary {padding: 10px 15px;}.submit-large {padding: 10px 15px;}.btn-large-secondary {background: #969799;color: #fff;border: 1px solid #969799;}.btn-large-secondary:hover {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary:active {background: #555659;color: #fff;border-color: #555659;}.btn-large-secondary .icon >path {fill: #e3e4e6;}a.btn,a.btn-large {color: #555659;}a.submit,a.submit-large,a.btn-large-secondary {color: #fff;}.dark-button {background: #2c2e2f;border: 1px solid rgba(106,124,131,0.75);color: #e3e4e6;-webkit-transition: background-color 0.15s;-moz-transition: background-color 0.15s;-o-transition: background-color 0.15s;-ms-transition: background-color 0.15s;transition: background-color 0.15s;}.dark-button .icon >path {fill: #dcdcdc;}.dark-button.disabled,.dark-button:disabled {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;pointer-events: none;}.dark-button.disabled .icon > path,.dark-button:disabled .icon > path {fill: rgba(106,124,131,0.5);}.dark-button.disabled.has-tip,.dark-button:disabled.has-tip {pointer-events: auto;}.dark-button.disabled.has-tip:hover,.dark-button:disabled.has-tip:hover {background: #3f484b;border: 1px solid rgba(106,124,131,0.5);color: #555659;}.dark-button.transparent {background-color: transparent;}.dark-button:hover {background: #1a1b1c;border-color: #7d8f95;color: #fcfcfc;}.dark-button:hover .icon > path {fill: #fff;}.dark-button:active {border-color: #dcdcdc;}.icon-only {position: relative;width: 32px;height: 30px;}.icon-only .icon {position: absolute;left: calc(50% - 8px);top: calc(50% - 8px);}.icon-only:hover .icon >path {fill: #555659;}.icon-only:active .icon >path {fill: #2c2e2f;}.icon-only.dark-button:hover .icon >path {fill: #fff;}.btn-invisible,.btn-no-style {color: #555659;padding: 5px 15px;border-color: transparent;-webkit-box-shadow: inset 0 0 0 1px transparent;box-shadow: inset 0 0 0 1px transparent;background: transparent;-webkit-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-moz-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-o-transition: background 0.15s, box-shadow 0.15s, color 0.15s;-ms-transition: background 0.15s, box-shadow 0.15s, color 0.15s;transition: background 0.15s, box-shadow 0.15s, color 0.15s;}.btn-invisible.disabled,.btn-no-style.disabled,.btn-invisible:disabled,.btn-no-style:disabled {cursor: default;}.btn-no-style {padding: 5px 10px 5px 0;vertical-align: baseline;}.btn-no-style:hover {border-color: transparent;color: #555659;}.btn-no-style:focus {border-radius: 0;outline: none;}.btn-no-style.dark {color: #7d8f95;}.btn-no-style.dark:hover {color: #f9f9f9;}.btn-no-style.dark:active {background: transparent;border-color: transparent;color: #fff;}.btn-no-style .css-icon::before {right: 0;}.link {display: inline-block;position: relative;cursor: pointer;-webkit-transition: all 0.15s;-moz-transition: all 0.15s;-o-transition: all 0.15s;-ms-transition: all 0.15s;transition: all 0.15s;}.link.has-icon {padding-left: 20px;}.link.has-icon .icon {position: absolute;left: 0;top: calc(50% - 8px);}.link.has-icon .icon >path {fill: #969799;}.link.has-icon .icon-plus,.link.has-icon .icon-close,.link.has-icon .icon-delete {top: calc(50% - 10px);}.link.has-icon:hover .icon >path {fill: #555659;}.link.has-icon:active .icon >path {fill: #0c92f3;}.link.dark,.popup-content .link {color: #7d8f95;}.link.dark .icon >path,.popup-content .link .icon >path {fill: #7d8f95;}.link.dark:hover,.popup-content .link:hover {color: #dcdcdc;}.link.dark:hover .icon >path,.popup-content .link:hover .icon >path {fill: #dcdcdc;}.link.dark:active,.popup-content .link:active {color: #fff;}.link.secondary {color: #969799;}.link.secondary:hover {color: #555659;}button.icon-btn {border: 0;background: none;padding: 0;}button.icon-btn:active {outline: none;}.icon-btn {display: inline-block;margin-left: 10px;vertical-align: middle;}.icon-btn .icon {display: block;}.icon-btn .icon >path {fill: #969799;}.icon-btn:hover .icon >path {fill: #555659;}.icon-btn.dark .icon >path {fill: #6a7c83;}.icon-btn.dark:hover .icon >path {fill: #f9f9f9;}.link-bar {display: block;margin-top: 16px;white-space: nowrap;}.link-bar.no-margin {margin-top: 0;}.link-bar .submit,.link-bar .submit-large,.link-bar .dark-button {min-width: 120px;}.link-bar a,.link-bar button {vertical-align: baseline;}.link-bar.right,.link-bar.center {text-align: right;}.link-bar.right a,.link-bar.center a,.link-bar.right button,.link-bar.center button {margin-right: 15px;}.link-bar.right .btn,.link-bar.center .btn,.link-bar.right .dark-button,.link-bar.center .dark-button,.link-bar.right .submit,.link-bar.center .submit {margin-right: 10px;}.link-bar.right *:nth-last-child(1),.link-bar.center *:nth-last-child(1) {margin-right: 0;}.link-bar.left {text-align: left;}.link-bar.left a,.link-bar.left button {margin-left: 15px;}.link-bar.left .btn,.link-bar.left .dark-button,.link-bar.left .submit {margin-left: 10px;}.link-bar.left *:first-child {margin-left: 0;}.link-bar.center {text-align: center;}input[type=radio],input[type=checkbox] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 17px;height: 17px;position: relative;border: 1px solid #dcdcdc;margin: 0;background: #fff;cursor: pointer;}input[type=radio].disabled,input[type=checkbox].disabled,input[type=radio]:disabled,input[type=checkbox]:disabled {background: #e3e4e6;}input[type=radio].dark,input[type=checkbox].dark {background: rgba(106,124,131,0.2);border-color: rgba(106,124,131,0.8);}input[type=radio].dark:checked,input[type=checkbox].dark:checked {background: #dcdcdc;}input[type=radio].dark:focus,input[type=checkbox].dark:focus {background: #f9f9f9;}input[type=radio].dark:active,input[type=checkbox].dark:active {background: #fff;}input[type=radio].dark.disabled,input[type=checkbox].dark.disabled,input[type=radio].dark:disabled,input[type=checkbox].dark:disabled {background: rgba(106,124,131,0.5);}input[type=radio] {border-radius: 8.5px;}input[type=radio]:active {background: #dcdcdc;}input[type=radio]:checked::after {position: absolute;content: "";height: 9px;width: 9px;left: calc(50% - 4.5px);top: calc(50% - 4.5px);border-radius: 4.25px;background-color: #0c92f3;}input[type=checkbox] {border-radius: 3px;}input[type=checkbox]:active {background: #dcdcdc;}input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: 3%;height: 40%;width: 69%;border-bottom: 2px solid #0c92f3;border-left: 2px solid #0c92f3;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}input[type=submit] {height: inherit;}input.required-checkbox[type=checkbox]:hover::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);left: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAADe0lEQVRYCe2WW0jTYRTA3V3pZRWEJJJFUQQFRtCFogt7kV7cxVkGmlBPdoHepCh6CCHoJYIIyvlgLYdzUfjQnSjoQXpIYUSZ9aZQQmNzDHVbvzPa+O/bf9sf0Tf/8PF9536+c853zt9Us4RvZGTkuMlkeqOITrrd7m0KriporsqxwgyrDqxGYDUCVnlloVBoK1vC7/fPrPCrK6gPh8P70+n0WM4Bq9XaB8VDg3nPHlpcXAzjzO8C9zIdhoeH95rN5nbUtdHINmUyGZeV29cBtICUejgmC4fuRiKRdzAMQYt4PJ5Z8Ev6MNqMUT/CfnRt0SqxWCw+bFnF+BotAUYLsAtBF/s9IvOaPRSLxSLd3d1/tbx6Zy61C71yUzFatj1Dc5tQ/pjDKT1FKi6bzc6De8WaROaSlg5thnUffDtrh5ZW6WyFuQ7BNLvcuuIHjx2GE3pM0OpZ1/Vo5XDYnTUzwdypVKoB4DyMH1jZcgLLhJcUDmCvZXx8vN6kKiV/DRRHG/k/CW2fSl8KjLEE0XnGs3tCYb/ghUkqc1+JA3mC7MFgsMlut0shSV73aGkGzkkMj8pLisfjoxRvSk+mogNaAWlWRKaLyFzV4tUzRqfAXUkkEs87OzvnVLoKG54FhE0qf62qQAduhG/KiHGRNewADaUVxT06BotQ8NhADAUCAWcRoQxgyAFqoZHQP9TT8T/kKqnJ6XQGVKQeXNUBcm+pra19xM3WqQowPsg6xNKbG62086JmpcoLXNUBWuo1+A7rCP9KJpM9Xq93mko/A72kf+DYLRlAOrIFVMVXQJs+Audbbl/kKIrT4I8ypD7mNcF7G77LeViz/1xYWGimiGMaXOFYpLiA5YDC9WwS+hIeHOjTGhc5Rngv22c5K99motiv4ApgifICpaamH+MNGjh3xPjYxMTEDRUv3Y2bSveMqzT0ePgBuaDiBdZNgTBT9Xd0BOZop80+n++7Di2HInKnMTio0nF8HvxBRk9RlEocoOq322y2LyhwqEootnMU3QMVr8I4MYCxLhWPEz9I1U7tLChJQTQaldv1wZxRFDw1YlxkaMM9yH9T5CU1vVrjQi+JQF6INLi4hRThBpRNM7J3d3R0/MnTq+3yK8bs+ASfRDJK6ryk7qsqV9YBYaQDbnQ4HEGcuEnuXqrC1WBScRGeA0TkrNHZUE3nstP/Ae08V3wBOebTAAAAAElFTkSuQmCC");background-position: 50% 50%;}input.required-checkbox[type=checkbox]:checked {border: none;background: #f26161;}input.required-checkbox[type=checkbox]:checked:hover {background: #d95757;}input.required-checkbox[type=checkbox]:checked:disabled {background: #f8b0b0;cursor: auto;}input[type=checkbox].required-checkbox:checked::after {position: absolute;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;top: calc(50% - 6px);content: "";width: 11px;height: 11px;border: none;background-size: contain;background-repeat: no-repeat;background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAABtklEQVRIDe2UzStEYRSHZwxpwpSNlNQUEQsbSztK7BUmbKzITvkPWMjKjpSywlIpSc1CkWxkQ5IslCQpHwvCeM6k27nnvnfuhKyceu49H79z3vv5xmJFWi6X2wBtjcW0lhQj+onmf4HIp/c3j4hPYxjqIi+nSAGzyqAXWmIc0iD2AbswAbV2FrmCnyn1UuiGJbgDsXlZYDLv+g/vhFkYgxpZjHNgAXIJ6IQFuAVrV9K4b7MmfiPegTOTXye+MblAGCfTzwUOQg+Uw2/ZCYPWvGEslIIR2IRX+I6d0zQNbd5gl4OgGkZhG+QRFbJLirPQ7poVmaNRvoww26IQjxwSJqC5Ak7Dpn/lh8L6I/MMWDbDX4gPTO6RuDlymBXQlDGDJJyCGriWQNkxftLOCI0RN8CDGiBuFvJ7F+cukJ9R22LoQF2gQ/aRQ92Jfw/1RjdjNBJmtMbpI5pzNMrP6DM0svfsGa28jyafUAcU5dZl09O2ojXaR5QGuTttRwQJrfN8CpWwqtQX+ClP4HCo9yn9E/6AQ+ZPIRqHZ+jwV9wROtlN5X9pdSscWcT5bdpRCqTQJqEqUCDxCYHVRpVrffeeAAAAAElFTkSuQmCC");background-position: 50% 50%;}input::placeholder,textarea::placeholder {color: #969799;}input:-ms-input-placeholder,textarea:-ms-input-placeholder {color: #969799;}.classic-input,.large-input {-webkit-transition: border-color 0.15s, background 0.15s;-moz-transition: border-color 0.15s, background 0.15s;-o-transition: border-color 0.15s, background 0.15s;-ms-transition: border-color 0.15s, background 0.15s;transition: border-color 0.15s, background 0.15s;border: 1px solid #e3e4e6;background-color: #fff;padding: 4px 10px;border-radius: 3px;}.classic-input.invalid,.large-input.invalid {border: 1px solid #d94141;}.classic-input.invalid:focus,.large-input.invalid:focus {outline: none;}.classic-input.invalid:hover,.large-input.invalid:hover {border: 1px solid #d94141;}.classic-input:hover,.large-input:hover {background-color: #fff;border-color: rgba(12,146,243,0.5);}.classic-input:active,.large-input:active,.classic-input:focus,.large-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #fff;border-color: #0c92f3;}.classic-input.disabled,.large-input.disabled,.classic-input:disabled,.large-input:disabled {background: #f9f9f9;color: #969799;}.classic-input.disabled:hover,.large-input.disabled:hover,.classic-input:disabled:hover,.large-input:disabled:hover,.classic-input.disabled:active,.large-input.disabled:active,.classic-input:disabled:active,.large-input:disabled:active {border-color: #e3e4e6;}.classic-input::-ms-clear,.large-input::-ms-clear {display: none;}textarea.classic-input {resize: vertical;}.hoverable-input {-webkit-transition: border-color 0.3s, background-color 0.3s;-moz-transition: border-color 0.3s, background-color 0.3s;-o-transition: border-color 0.3s, background-color 0.3s;-ms-transition: border-color 0.3s, background-color 0.3s;transition: border-color 0.3s, background-color 0.3s;border: 1px solid transparent;background-color: transparent;padding: 4px 10px;border-radius: 3px;}.hoverable-input.invalid {border: 1px solid #d94141;outline: none;}.hoverable-input:hover {background-color: #fff;border-color: #e3e4e6;}.hoverable-input:active,.hoverable-input:focus {outline: none;-webkit-box-shadow: none;box-shadow: none;background-color: #f9f9f9;border-color: #e3e4e6;}.dark-input,.large-input.dark {height: 30px;color: #f9f9f9;padding: 4px 10px;background: rgba(106,124,131,0.5);border: none;color: #e3e4e6;border-radius: 3px;}.dark-input.invalid,.large-input.dark.invalid {border: 1px solid #d94141;}.dark-input.invalid:focus,.large-input.dark.invalid:focus {outline: none;}.dark-input.invalid:hover,.large-input.dark.invalid:hover {border: 1px solid #d94141;}.dark-input:hover,.large-input.dark:hover {background: #6a7c83;}.dark-input:focus,.large-input.dark:focus {background: #fff;color: #555659;outline: none;}textarea.dark-input {height: auto;}.large-input {height: 40px;}.large-input.dark {height: 40px;}.no-input {background: none;border: none;outline: none;-webkit-box-shadow: none;box-shadow: none;margin: 0;padding: 0;resize: none;}.no-input.dark {color: #f9f9f9;}.options-list {list-style-type: none;}.options-list li {margin-bottom: 8px;}.options-list li.list-padding {margin-bottom: 16px;}.options-list label {display: block;position: relative;cursor: pointer;}.options-list label input[type=checkbox],.options-list label input[type=radio] {position: absolute;}.options-list label input[type=checkbox] ~ span,.options-list label input[type=radio] ~ span,.options-list label input[type=checkbox] ~ p,.options-list label input[type=radio] ~ p {padding-left: 26px;display: block;color: #555659;}.options-list label input[type=checkbox]:checked ~ span,.options-list label input[type=radio]:checked ~ span,.options-list label input[type=checkbox]:checked ~ p,.options-list label input[type=radio]:checked ~ p {color: #555659;}.popup-content .options-list input[type="checkbox"],.sheets-content .options-list input[type="checkbox"],.modal-legacy.dark .options-list input[type="checkbox"],.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {background: rgba(106,124,131,0.5);border-color: rgba(106,124,131,0.8);}.popup-content .options-list input[type="checkbox"] ~ span,.sheets-content .options-list input[type="checkbox"] ~ span,.modal-legacy.dark .options-list input[type="checkbox"] ~ span,.popup-content .options-list input[type="radio"] ~ span,.sheets-content .options-list input[type="radio"] ~ span,.modal-legacy.dark .options-list input[type="radio"] ~ span,.popup-content .options-list input[type="checkbox"] ~ p,.sheets-content .options-list input[type="checkbox"] ~ p,.modal-legacy.dark .options-list input[type="checkbox"] ~ p,.popup-content .options-list input[type="radio"] ~ p,.sheets-content .options-list input[type="radio"] ~ p,.modal-legacy.dark .options-list input[type="radio"] ~ p {color: #a4b0b4;}.popup-content .options-list input[type="checkbox"]:checked,.sheets-content .options-list input[type="checkbox"]:checked,.modal-legacy.dark .options-list input[type="checkbox"]:checked,.popup-content .options-list input[type="radio"]:checked,.sheets-content .options-list input[type="radio"]:checked,.modal-legacy.dark .options-list input[type="radio"]:checked {background: #dcdcdc;}.popup-content .options-list input[type="checkbox"]:checked ~ span,.sheets-content .options-list input[type="checkbox"]:checked ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ span,.popup-content .options-list input[type="radio"]:checked ~ span,.sheets-content .options-list input[type="radio"]:checked ~ span,.modal-legacy.dark .options-list input[type="radio"]:checked ~ span,.popup-content .options-list input[type="checkbox"]:checked ~ p,.sheets-content .options-list input[type="checkbox"]:checked ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:checked ~ p,.popup-content .options-list input[type="radio"]:checked ~ p,.sheets-content .options-list input[type="radio"]:checked ~ p,.modal-legacy.dark .options-list input[type="radio"]:checked ~ p {color: #f9f9f9;}.popup-content .options-list input[type="checkbox"]:focus,.sheets-content .options-list input[type="checkbox"]:focus,.modal-legacy.dark .options-list input[type="checkbox"]:focus,.popup-content .options-list input[type="radio"]:focus,.sheets-content .options-list input[type="radio"]:focus,.modal-legacy.dark .options-list input[type="radio"]:focus {background: #f9f9f9;}.popup-content .options-list input[type="checkbox"].disabled,.sheets-content .options-list input[type="checkbox"].disabled,.modal-legacy.dark .options-list input[type="checkbox"].disabled,.popup-content .options-list input[type="radio"].disabled,.sheets-content .options-list input[type="radio"].disabled,.modal-legacy.dark .options-list input[type="radio"].disabled,.popup-content .options-list input[type="checkbox"]:disabled,.sheets-content .options-list input[type="checkbox"]:disabled,.modal-legacy.dark .options-list input[type="checkbox"]:disabled,.popup-content .options-list input[type="radio"]:disabled,.sheets-content .options-list input[type="radio"]:disabled,.modal-legacy.dark .options-list input[type="radio"]:disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="checkbox"].disabled ~ span,.sheets-content .options-list input[type="checkbox"].disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ span,.popup-content .options-list input[type="radio"].disabled ~ span,.sheets-content .options-list input[type="radio"].disabled ~ span,.modal-legacy.dark .options-list input[type="radio"].disabled ~ span,.popup-content .options-list input[type="checkbox"]:disabled ~ span,.sheets-content .options-list input[type="checkbox"]:disabled ~ span,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ span,.popup-content .options-list input[type="radio"]:disabled ~ span,.sheets-content .options-list input[type="radio"]:disabled ~ span,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ span,.popup-content .options-list input[type="checkbox"].disabled ~ p,.sheets-content .options-list input[type="checkbox"].disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"].disabled ~ p,.popup-content .options-list input[type="radio"].disabled ~ p,.sheets-content .options-list input[type="radio"].disabled ~ p,.modal-legacy.dark .options-list input[type="radio"].disabled ~ p,.popup-content .options-list input[type="checkbox"]:disabled ~ p,.sheets-content .options-list input[type="checkbox"]:disabled ~ p,.modal-legacy.dark .options-list input[type="checkbox"]:disabled ~ p,.popup-content .options-list input[type="radio"]:disabled ~ p,.sheets-content .options-list input[type="radio"]:disabled ~ p,.modal-legacy.dark .options-list input[type="radio"]:disabled ~ p {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.popup-content .options-list input[type="radio"],.sheets-content .options-list input[type="radio"],.modal-legacy.dark .options-list input[type="radio"] {border-radius: 8.5px;}.loading-indicator {display: inline-block;border-radius: 30px;-webkit-animation: loading 1.2s infinite linear;-moz-animation: loading 1.2s infinite linear;-o-animation: loading 1.2s infinite linear;-ms-animation: loading 1.2s infinite linear;animation: loading 1.2s infinite linear;width: 30px;height: 30px;border: 4px solid #0c92f3;border-top: 4px solid #e3e4e6;border-left: 4px solid #e3e4e6;vertical-align: middle;}.loading-indicator.small {margin-right: 10px;width: 16px;height: 16px;border: 2px solid #0c92f3;border-top: 2px solid #e3e4e6;border-left: 2px solid #e3e4e6;}.loading-indicator.small.completed {border: 2px solid #555659;}.loading-indicator.small.completed .icon {vertical-align: top;width: 10px;height: 10px;}.loading-indicator.completed {border: 4px solid #555659;text-align: center;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;}.loading-indicator .icon {margin-left: 1px;height: 100%;vertical-align: middle;}.loading-indicator .icon >path {fill: #39bf87;}.loading-indicator.fadein {-webkit-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-moz-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-o-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;-ms-animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;animation: loading 1.2s linear infinite, lever-fadein 300ms ease-in 150ms;}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}.css-icon {display: inline-block;width: 16px;height: 1px;}.css-icon::before {position: absolute;display: block;content: "";right: 10px;top: calc(50% - 8px);width: 16px;height: 16px;}.css-icon-plus::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path d='M7.5,3h1v4.5H13v1H8.5V13h-1V8.5H3v-1h4.5V3z'></path></svg>") no-repeat 0 0;}.css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23979797' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.btn-no-style.dark:hover .css-icon-caret-down::before {background: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16'><path fill='%23DCDCDC' d='M8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12zM8 12l6.8-7.3L14.1 4l-6.1 6.5L1.9 4l-0.7 0.7L8 12z'></path></svg>") no-repeat 0 0;}.toggle-label {clear: left;color: #969799;line-height: 22px;}.toggle-label button {float: left;margin-right: 10px;}.toggle-slider {margin-left: 10px;background: #fff;width: 45px;height: 22px;border-radius: 11px;position: relative;vertical-align: middle;border: 1px solid #dcdcdc;-webkit-transition: background 150ms;-moz-transition: background 150ms;-o-transition: background 150ms;-ms-transition: background 150ms;transition: background 150ms;}.toggle-slider:focus {outline: none;}.toggle-slider:hover {background-color: #f9f9f9;}.toggle-slider .ball {height: 16px;width: 16px;border-radius: 8px;position: absolute;background-color: #dcdcdc;left: 2px;top: 2px;right: auto;-webkit-transition: 150ms;-moz-transition: 150ms;-o-transition: 150ms;-ms-transition: 150ms;transition: 150ms;}.toggle-slider .ball:hover {background: #969799;}.toggle-slider.on .ball {left: 25px;background: #39bf87;}.toggle-slider.on .ball:hover {background: #30a272;}.message-banner {position: relative;display: inline-block;margin-bottom: 20px;padding: 9px 15px;border-radius: 3px;background: #e1f3ff;color: #6a7c83;}.message-banner.full-width {display: block;}.message-banner.centered {text-align: center;}.message-banner.has-icon {padding-left: 41px;}.message-banner.has-dismiss {padding-right: 41px;}.message-banner.has-dismiss .icon-btn {position: absolute;right: 15px;top: 6px;}.message-banner.has-dismiss .icon-btn .icon {position: relative;left: inherit;top: inherit;}.message-banner.has-button {padding-top: 14px;padding-right: 180px;padding-bottom: 14px;}.message-banner.has-button .icon {top: 15px;}.message-banner.has-button .btn,.message-banner.has-button button {position: absolute;right: 10px;top: 10px;}.message-banner a,.message-banner a:visited {color: #555659;}.message-banner a:hover,.message-banner a:visited:hover {color: #1a1b1c;}.message-banner .icon {position: absolute;left: 15px;top: 10px;}.message-banner .icon >path {fill: #6a7c83;}.message-banner .label {color: #555659;}.message-banner .btn {float: right;}.message-banner.warning {background: #fec;}.message-banner.error {background: #ffe6e6;color: #555659;}.message-banner.error .label {color: #555659;}.message-banner.error .icon >path {fill: #555659;}.what-is-this {display: inline-block;color: #969799;cursor: default;padding-left: 4px;font-size: 12px;}.what-is-this.dark {color: #6a7c83;}.what-is-this.dark:hover {color: #f9f9f9;}.what-is-this .icon >path {fill: #969799;}.what-is-this:hover {color: #555659;}.what-is-this:hover .icon >path {fill: #555659;}.what-is-this-icon {display: inline-block;margin-left: 10px;}.what-is-this-icon .icon {width: 12px;height: 12px;}.what-is-this-icon .icon >path {fill: #969799;}.what-is-this-icon:hover .icon >path {fill: #555659;}.what-is-this-icon.no-margin {margin-left: 4px;}.what-is-this-icon.dark .icon >path {fill: #6a7c83;}.what-is-this-icon.dark:hover .icon >path {fill: #dde5e7;}.gated-feature,.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter,.gated-feature-block,.gated-feature-block-pro {position: relative;cursor: pointer;background: rgba(227,228,230,0.5);}.gated-feature:before,.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before,.gated-feature-block:before,.gated-feature-block-pro:before {content: 'Enterprise';font-size: 12px;color: #fff;background-color: #39bf87;border-radius: 3px;padding: 2px 10px;position: absolute;right: 15px;}.gated-feature:after,.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after,.gated-feature-block:after,.gated-feature-block-pro:after {cursor: pointer;content: '';border-radius: 3px;border: 1px solid #e3e4e6;}.gated-feature-inline,.gated-feature-inline-enterprise,.gated-feature-inline-professional,.gated-feature-inline-starter {border: 1px solid #e3e4e6;border-radius: 3px;}.gated-feature-inline:before,.gated-feature-inline-enterprise:before,.gated-feature-inline-professional:before,.gated-feature-inline-starter:before {content: 'Enterprise';position: absolute;float: right;top: 50%;-webkit-transform: translateY(-50%);-moz-transform: translateY(-50%);-o-transform: translateY(-50%);-ms-transform: translateY(-50%);transform: translateY(-50%);margin-left: 10px;}.gated-feature-inline:after,.gated-feature-inline-enterprise:after,.gated-feature-inline-professional:after,.gated-feature-inline-starter:after {content: none;display: none;}.gated-feature-inline *,.gated-feature-inline-enterprise *,.gated-feature-inline-professional *,.gated-feature-inline-starter * {pointer-events: none;}.gated-feature-inline-professional:before {content: 'Pro';}.gated-feature-inline-starter:before {content: 'Starter';}.gated-feature-block,.gated-feature-block-pro {margin-top: 32px;padding: 15px 15px;}.gated-feature-block:before,.gated-feature-block-pro:before {top: 15px;-webkit-transform: none;-moz-transform: none;-o-transform: none;-ms-transform: none;transform: none;}.gated-feature-block:after,.gated-feature-block-pro:after {pointer-events: none;}.gated-feature-block-pro:before {content: 'Pro';}.gated-ad {max-width: 600px;min-height: 270px;}.gated-ad .pull-left {float: left;margin-right: 70px;}.gated-ad div.pull-left,.gated-ad div.image {margin-top: 25px;}.gated-ad ul li {margin: 0 0 32px 0;list-style: none;}.gated-ad ul li .icon {vertical-align: sub;margin-right: 10px;}.gated-ad ul li .icon > path {fill: #969799;}.momentum-body,.badge,.theme-inverse .button.button-link,.button.button-link,.font-base {font-family: 'Meta', sans-serif;letter-spacing: 0;text-transform: none;}.momentum-body .icon,.badge .icon,.theme-inverse .button.button-link .icon,.button.button-link .icon,.font-base .icon,.momentum-body .momentum-body .icon,.momentum-body .badge .icon,.momentum-body .theme-inverse .button.button-link .icon,.momentum-body .button.button-link .icon,.momentum-body .font-base .icon {vertical-align: -0.15em;}.momentum-body {color: #222326;font-size: 16px;font-weight: normal;line-height: 24px;margin: 0;}.button,.mo-identicon-initials,.col-list-row-header,.nav-link,.font-caps {font-family: 'Meta-Caps', 'Meta', sans-serif;letter-spacing: 1px;text-transform: lowercase;}.button .icon,.mo-identicon-initials .icon,.col-list-row-header .icon,.nav-link .icon,.font-caps .icon,.momentum-body .button .icon,.momentum-body .mo-identicon-initials .icon,.momentum-body .col-list-row-header .icon,.momentum-body .nav-link .icon,.momentum-body .font-caps .icon {vertical-align: -0.188em;}.form-control,.font-inherit {font-family: inherit;letter-spacing: inherit;text-transform: inherit;}.theme-inverse .button {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.theme-inverse,.theme-inverse .text-base,.theme-inverse .text-small,.theme-inverse .text-caption {-moz-osx-font-smoothing: auto;-webkit-font-smoothing: auto;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5,.momentum-body b,.momentum-body strong,.text-h1,.text-h2,.text-h3,.text-h3_5,.text-h4,.text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5,.theme-inverse b,.theme-inverse strong,.theme-inverse .text-h1,.theme-inverse .text-h2,.theme-inverse .text-h3,.theme-inverse .text-h3_5,.theme-inverse .text-h4,.theme-inverse .text-h5 {-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased;}.theme-inverse {background-color: #3b3d3f;color: #d7d7d9;}.card {border-radius: 3px;-webkit-box-shadow: 0 1px 1px rgba(0,0,0,0.15);box-shadow: 0 1px 1px rgba(0,0,0,0.15);}.momentum-body p {margin-bottom: 16px;margin-top: 0;}.momentum-body h1,.momentum-body h2,.momentum-body h3,.momentum-body h4,.momentum-body h5 {color: #222326;font-weight: bold;margin-bottom: 8px;margin-top: 0;text-transform: none;}.momentum-body h1 {font-size: 40px;line-height: 48px;}.momentum-body h2 {font-size: 32px;line-height: 40px;}.momentum-body h3 {font-size: 24px;line-height: 36px;}.momentum-body h4 {font-size: 16px;letter-spacing: 0;font-family: 'Meta', sans-serif;line-height: 24px;}.momentum-body h5 {font-size: 14px;line-height: 21px;}.momentum-body small {font-size: 14px;line-height: 21px;}.momentum-body ol,.momentum-body ul {margin-bottom: 16px;margin-top: 0;padding-left: 16px;}.momentum-body ol ol,.momentum-body ul ol,.momentum-body ol ul,.momentum-body ul ul {margin-bottom: 0;}.momentum-body b,.momentum-body strong {font-weight: bolder;}.momentum-body a {-webkit-text-decoration-skip: objects;background-color: transparent;color: inherit;text-decoration: underline;}.momentum-body a:visited {color: inherit;}.momentum-body a:hover {color: #0068b3;}.momentum-body a:active {color: #003459;}.momentum-body a.strikethrough {text-decoration: line-through;}.momentum-body a.text-muted {color: #555659;}.momentum-body a.text-decoration-none {text-decoration: none;}.momentum-body a.underline-on-hover {text-decoration: none;}.momentum-body a.underline-on-hover:hover,.momentum-body a.underline-on-hover:active,.momentum-body a.underline-on-hover:focus {text-decoration: underline;}.momentum-body hr {background: #e3e4e6;border: none;height: 1px;margin-bottom: 4px;margin-top: 3px;}.momentum-body section {margin-bottom: 32px;}.momentum-body input[type=text] {height: auto;}.momentum-body button {cursor: pointer;}.momentum-body .icon {display: inline-block;height: 16px;margin-left: 8px;margin-right: 8px;width: 16px;}.momentum-body .icon:not(.icon-ms-teams) > path {fill: currentColor;}.momentum-body .icon:first-child {margin-left: 0;}.momentum-body .icon:last-child {margin-right: 0;}.momentum-body .icon-large {height: 24px;margin-left: 8px;margin-right: 8px;width: 24px;}.momentum-body .icon-small {height: 14px;width: 14px;margin-left: 8px;margin-right: 8px;}.momentum-body .icon-caption {height: 12px;width: 12px;margin-left: 4px;margin-right: 4px;}.momentum-body .icon-thumbnail {height: 48px;margin-left: $iconThumbnailMarginX;margin-right: $iconThumbnailMarginX;width: 48px;}.badge {border-radius: 3px;display: inline-block;font-size: 14px;height: 20px;line-height: 20px;margin-left: 8px;margin-right: 8px;min-width: 20px;padding-left: 4px;padding-right: 4px;text-align: center;}.badge:first-child {margin-left: 0;}.badge:last-child {margin-right: 0;}.badge {background-color: #e3e4e6;color: #969799;}.theme-inverse .badge {background-color: #555659;color: #d7d7d9;}.theme-inverse .badge.badge-default {background-color: #e3e4e6;color: #969799;}.badge.badge-primary {background-color: #0c92f3;color: #fff;}.badge.badge-secondary {background-color: #969799;color: #fff;}.badge.badge-positive {background-color: #39bf71;color: #fff;}.badge.badge-negative {background-color: #d94141;color: #fff;}.badge.badge-inverse {background-color: #555659;color: #d7d7d9;}.badge.badge-white {background-color: #fff;color: #555659;}.badge.badge-gray {background-color: #969799;color: #fff;}.badge.badge-black {background-color: #000;color: #fff;}.badge.badge-small {font-size: 12px;height: 18px;line-height: 18px;min-width: 18px;}.badge.badge-caption {font-size: 12px;height: 16px;line-height: 16px;min-width: 16px;}.button,a.button {background-color: #fff;background-image: -webkit-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -moz-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -o-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: -ms-linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);background-image: linear-gradient(rgba(249,249,249,0) 0%, #f9f9f9 100%);border: 1px solid rgba(215,215,217,0.7);color: #555659;padding: 7px 15px;}.button:hover,a.button:hover,.button.hover,a.button.hover {background-color: #fff;border-color: #b1b1b3;color: #555659;}.button:focus,a.button:focus,.button.focus,a.button.focus {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.button:active,a.button:active,.button.active,a.button.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #222326;}.button.selected,a.button.selected {background-color: #e3e4e6;color: #222326;}.button[disabled],a.button[disabled],.button.disabled,a.button.disabled {cursor: not-allowed;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.button[disabled]:hover,a.button[disabled]:hover,.button.disabled:hover,a.button.disabled:hover,.button[disabled]:active,a.button[disabled]:active,.button.disabled:active,a.button.disabled:active {background-color: #fff;background-image: $buttonBackgroundGradient;border-color: rgba(215,215,217,0.7);color: #555659;}.button.button-square,a.button.button-square {padding: 7px 11px;}.button.button-lg,a.button.button-lg {padding: 5px 15px;}.button.button-lg.button-square,a.button.button-lg.button-square {padding: 5px 14px;}.button.button-sm,a.button.button-sm {padding: 3px 15px;}.button.button-sm.button-square,a.button.button-sm.button-square {padding: 3px 8px;}.button-group .button:hover,.button-group a.button:hover {border-right-width: 1px;}.button-group .button:hover + .button,.button-group a.button:hover + .button {margin-left: 0;border-left-width: 0;}.button {border-radius: 3px;cursor: pointer;display: inline-block;font-size: 14px;line-height: 24px;margin-right: 8px;text-align: center;-webkit-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out, background-color 0.15s ease-in-out;}.button,.momentum-body .button {text-decoration: none;}.button:last-child {margin-right: 0;}.button .icon {margin-left: 12px;margin-right: 12px;opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);-webkit-transition: opacity 0.15s ease-in-out;-moz-transition: opacity 0.15s ease-in-out;-o-transition: opacity 0.15s ease-in-out;-ms-transition: opacity 0.15s ease-in-out;transition: opacity 0.15s ease-in-out;}.button .icon:first-child {margin-left: 0;}.button .icon:last-child {margin-right: 0;}.theme-inverse .button {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.theme-inverse .button .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button:visited {color: #fff;}.theme-inverse .button:hover,.theme-inverse .button.hover {background-color: #707173;border-color: #969799;color: #fff;}.theme-inverse .button:hover .icon,.theme-inverse .button.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.theme-inverse .button:active,.theme-inverse .button.active {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button.selected {background-color: #969799;border-color: #969799;color: #fff;}.theme-inverse .button[disabled]:hover,.theme-inverse .button.disabled:hover,.theme-inverse .button[disabled]:active,.theme-inverse .button.disabled:active {background-color: #555659;background-image: none;color: #fff;}.theme-inverse .button[disabled]:hover .icon,.theme-inverse .button.disabled:hover .icon,.theme-inverse .button[disabled]:active .icon,.theme-inverse .button.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.theme-inverse .button.button-square {padding: 8px 12px;}.theme-inverse .button.button-lg {padding: 6px 16px;}.theme-inverse .button.button-lg.button-square {padding: 6px 15px;}.theme-inverse .button.button-sm {padding: 4px 16px;}.theme-inverse .button.button-sm.button-square {padding: 4px 9px;}.button-group .theme-inverse .button:hover {border-right-width: 0;}.button-group .theme-inverse .button:hover + .button {margin-left: -1px;border-left-width: 1px;}.theme-inverse .button.button-link {border: none;background-color: transparent;background-image: none;color: #969799;padding: 0;text-decoration: underline;text-transform: none;}.theme-inverse .button.button-link:visited {color: #969799;}.theme-inverse .button.button-link:hover {color: #d7d7d9;}.theme-inverse .button.button-link:active {color: #0c92f3;}.theme-inverse .button.button-link.text-decoration-none {text-decoration: none;}.button.button-link {border: none;background-color: transparent;background-image: none;color: inherit;padding: 0;text-decoration: underline;text-transform: none;}.button.button-link:visited {color: inherit;}.button.button-link:hover {color: #0068b3;border: none;background-color: transparent;background-image: none;}.button.button-link:active {color: #003459;}.button.button-link.text-decoration-none {text-decoration: none;}.button.button-primary,.button.button-blue {background-color: #0c92f3;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-primary .icon,.button.button-blue .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:visited,.button.button-blue:visited {color: #fff;}.button.button-primary:hover,.button.button-blue:hover,.button.button-primary.hover,.button.button-blue.hover {background-color: #007fd9;border-color: #fff;color: #fff;}.button.button-primary:hover .icon,.button.button-blue:hover .icon,.button.button-primary.hover .icon,.button.button-blue.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary:active,.button.button-blue:active,.button.button-primary.active,.button.button-blue.active {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary.selected,.button.button-blue.selected {background-color: #0068b3;border-color: #fff;color: #fff;}.button.button-primary[disabled]:hover,.button.button-blue[disabled]:hover,.button.button-primary.disabled:hover,.button.button-blue.disabled:hover,.button.button-primary[disabled]:active,.button.button-blue[disabled]:active,.button.button-primary.disabled:active,.button.button-blue.disabled:active {background-color: #0c92f3;background-image: none;color: #fff;}.button.button-primary[disabled]:hover .icon,.button.button-blue[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-blue.disabled:hover .icon,.button.button-primary[disabled]:active .icon,.button.button-blue[disabled]:active .icon,.button.button-primary.disabled:active .icon,.button.button-blue.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary.button-square,.button.button-blue.button-square {padding: 8px 12px;}.button.button-primary.button-lg,.button.button-blue.button-lg {padding: 6px 16px;}.button.button-primary.button-lg.button-square,.button.button-blue.button-lg.button-square {padding: 6px 15px;}.button.button-primary.button-sm,.button.button-blue.button-sm {padding: 4px 16px;}.button.button-primary.button-sm.button-square,.button.button-blue.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary:hover,.button-group .button.button-blue:hover {border-right-width: 0;}.button-group .button.button-primary:hover + .button,.button-group .button.button-blue:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-primary[disabled],.button.button-primary.disabled {background-color: #e3e4e6;background-image: none;border-color: #d7d7d9;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-primary[disabled] .icon,.button.button-primary.disabled .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled]:visited,.button.button-primary.disabled:visited {color: #555659;}.button.button-primary[disabled]:hover,.button.button-primary.disabled:hover,.button.button-primary[disabled].hover,.button.button-primary.disabled.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled]:hover .icon,.button.button-primary.disabled:hover .icon,.button.button-primary[disabled].hover .icon,.button.button-primary.disabled.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-primary[disabled]:active,.button.button-primary.disabled:active,.button.button-primary[disabled].active,.button.button-primary.disabled.active {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled].selected,.button.button-primary.disabled.selected {background-color: #b1b1b3;border-color: #d7d7d9;color: #555659;}.button.button-primary[disabled][disabled]:hover,.button.button-primary.disabled[disabled]:hover,.button.button-primary[disabled].disabled:hover,.button.button-primary.disabled.disabled:hover,.button.button-primary[disabled][disabled]:active,.button.button-primary.disabled[disabled]:active,.button.button-primary[disabled].disabled:active,.button.button-primary.disabled.disabled:active {background-color: #e3e4e6;background-image: none;color: #555659;}.button.button-primary[disabled][disabled]:hover .icon,.button.button-primary.disabled[disabled]:hover .icon,.button.button-primary[disabled].disabled:hover .icon,.button.button-primary.disabled.disabled:hover .icon,.button.button-primary[disabled][disabled]:active .icon,.button.button-primary.disabled[disabled]:active .icon,.button.button-primary[disabled].disabled:active .icon,.button.button-primary.disabled.disabled:active .icon {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.button.button-primary[disabled].button-square,.button.button-primary.disabled.button-square {padding: 8px 12px;}.button.button-primary[disabled].button-lg,.button.button-primary.disabled.button-lg {padding: 6px 16px;}.button.button-primary[disabled].button-lg.button-square,.button.button-primary.disabled.button-lg.button-square {padding: 6px 15px;}.button.button-primary[disabled].button-sm,.button.button-primary.disabled.button-sm {padding: 4px 16px;}.button.button-primary[disabled].button-sm.button-square,.button.button-primary.disabled.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-primary[disabled]:hover,.button-group .button.button-primary.disabled:hover {border-right-width: 0;}.button-group .button.button-primary[disabled]:hover + .button,.button-group .button.button-primary.disabled:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-positive,.button.button-green {background-color: #39bf71;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-positive .icon,.button.button-green .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:visited,.button.button-green:visited {color: #fff;}.button.button-positive:hover,.button.button-green:hover,.button.button-positive.hover,.button.button-green.hover {background-color: #19a654;border-color: #fff;color: #fff;}.button.button-positive:hover .icon,.button.button-green:hover .icon,.button.button-positive.hover .icon,.button.button-green.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive:active,.button.button-green:active,.button.button-positive.active,.button.button-green.active {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive.selected,.button.button-green.selected {background-color: #0e8c42;border-color: #fff;color: #fff;}.button.button-positive[disabled]:hover,.button.button-green[disabled]:hover,.button.button-positive.disabled:hover,.button.button-green.disabled:hover,.button.button-positive[disabled]:active,.button.button-green[disabled]:active,.button.button-positive.disabled:active,.button.button-green.disabled:active {background-color: #39bf71;background-image: none;color: #fff;}.button.button-positive[disabled]:hover .icon,.button.button-green[disabled]:hover .icon,.button.button-positive.disabled:hover .icon,.button.button-green.disabled:hover .icon,.button.button-positive[disabled]:active .icon,.button.button-green[disabled]:active .icon,.button.button-positive.disabled:active .icon,.button.button-green.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-positive.button-square,.button.button-green.button-square {padding: 8px 12px;}.button.button-positive.button-lg,.button.button-green.button-lg {padding: 6px 16px;}.button.button-positive.button-lg.button-square,.button.button-green.button-lg.button-square {padding: 6px 15px;}.button.button-positive.button-sm,.button.button-green.button-sm {padding: 4px 16px;}.button.button-positive.button-sm.button-square,.button.button-green.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-positive:hover,.button-group .button.button-green:hover {border-right-width: 0;}.button-group .button.button-positive:hover + .button,.button-group .button.button-green:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-negative,.button.button-red {background-color: #d94141;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-negative .icon,.button.button-red .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:visited,.button.button-red:visited {color: #fff;}.button.button-negative:hover,.button.button-red:hover,.button.button-negative.hover,.button.button-red.hover {background-color: #bf3939;border-color: #fff;color: #fff;}.button.button-negative:hover .icon,.button.button-red:hover .icon,.button.button-negative.hover .icon,.button.button-red.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative:active,.button.button-red:active,.button.button-negative.active,.button.button-red.active {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative.selected,.button.button-red.selected {background-color: #a62929;border-color: #fff;color: #fff;}.button.button-negative[disabled]:hover,.button.button-red[disabled]:hover,.button.button-negative.disabled:hover,.button.button-red.disabled:hover,.button.button-negative[disabled]:active,.button.button-red[disabled]:active,.button.button-negative.disabled:active,.button.button-red.disabled:active {background-color: #d94141;background-image: none;color: #fff;}.button.button-negative[disabled]:hover .icon,.button.button-red[disabled]:hover .icon,.button.button-negative.disabled:hover .icon,.button.button-red.disabled:hover .icon,.button.button-negative[disabled]:active .icon,.button.button-red[disabled]:active .icon,.button.button-negative.disabled:active .icon,.button.button-red.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-negative.button-square,.button.button-red.button-square {padding: 8px 12px;}.button.button-negative.button-lg,.button.button-red.button-lg {padding: 6px 16px;}.button.button-negative.button-lg.button-square,.button.button-red.button-lg.button-square {padding: 6px 15px;}.button.button-negative.button-sm,.button.button-red.button-sm {padding: 4px 16px;}.button.button-negative.button-sm.button-square,.button.button-red.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-negative:hover,.button-group .button.button-red:hover {border-right-width: 0;}.button-group .button.button-negative:hover + .button,.button-group .button.button-red:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-inverse,.button.button-gray {background-color: #555659;background-image: none;border-color: #969799;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-inverse .icon,.button.button-gray .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse:visited,.button.button-gray:visited {color: #fff;}.button.button-inverse:hover,.button.button-gray:hover,.button.button-inverse.hover,.button.button-gray.hover {background-color: #707173;border-color: #969799;color: #fff;}.button.button-inverse:hover .icon,.button.button-gray:hover .icon,.button.button-inverse.hover .icon,.button.button-gray.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-inverse:active,.button.button-gray:active,.button.button-inverse.active,.button.button-gray.active {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse.selected,.button.button-gray.selected {background-color: #969799;border-color: #969799;color: #fff;}.button.button-inverse[disabled]:hover,.button.button-gray[disabled]:hover,.button.button-inverse.disabled:hover,.button.button-gray.disabled:hover,.button.button-inverse[disabled]:active,.button.button-gray[disabled]:active,.button.button-inverse.disabled:active,.button.button-gray.disabled:active {background-color: #555659;background-image: none;color: #fff;}.button.button-inverse[disabled]:hover .icon,.button.button-gray[disabled]:hover .icon,.button.button-inverse.disabled:hover .icon,.button.button-gray.disabled:hover .icon,.button.button-inverse[disabled]:active .icon,.button.button-gray[disabled]:active .icon,.button.button-inverse.disabled:active .icon,.button.button-gray.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-inverse.button-square,.button.button-gray.button-square {padding: 8px 12px;}.button.button-inverse.button-lg,.button.button-gray.button-lg {padding: 6px 16px;}.button.button-inverse.button-lg.button-square,.button.button-gray.button-lg.button-square {padding: 6px 15px;}.button.button-inverse.button-sm,.button.button-gray.button-sm {padding: 4px 16px;}.button.button-inverse.button-sm.button-square,.button.button-gray.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-inverse:hover,.button-group .button.button-gray:hover {border-right-width: 0;}.button-group .button.button-inverse:hover + .button,.button-group .button.button-gray:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet {background-color: #a452cc;background-image: none;border-color: #fff;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-violet .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:visited {color: #fff;}.button.button-violet:hover,.button.button-violet.hover {background-color: #9c2bd4;border-color: #fff;color: #fff;}.button.button-violet:hover .icon,.button.button-violet.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet:active,.button.button-violet.active {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet.selected {background-color: #801bb2;border-color: #fff;color: #fff;}.button.button-violet[disabled]:hover,.button.button-violet.disabled:hover,.button.button-violet[disabled]:active,.button.button-violet.disabled:active {background-color: #a452cc;background-image: none;color: #fff;}.button.button-violet[disabled]:hover .icon,.button.button-violet.disabled:hover .icon,.button.button-violet[disabled]:active .icon,.button.button-violet.disabled:active .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet.button-square {padding: 8px 12px;}.button.button-violet.button-lg {padding: 6px 16px;}.button.button-violet.button-lg.button-square {padding: 6px 15px;}.button.button-violet.button-sm {padding: 4px 16px;}.button.button-violet.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet:hover {border-right-width: 0;}.button-group .button.button-violet:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-violet-light {background-color: #f5e0ff;background-image: none;border-color: #f5e0ff;border-width: 0;color: #620e8c;padding: 8px 16px;}.button.button-violet-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light:visited {color: #620e8c;}.button.button-violet-light:hover,.button.button-violet-light.hover {background-color: #ebc4ff;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light:hover .icon,.button.button-violet-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-violet-light:active,.button.button-violet-light.active {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light.selected {background-color: #dea2fc;border-color: #f5e0ff;color: #620e8c;}.button.button-violet-light[disabled]:hover,.button.button-violet-light.disabled:hover,.button.button-violet-light[disabled]:active,.button.button-violet-light.disabled:active {background-color: #f5e0ff;background-image: none;color: #620e8c;}.button.button-violet-light[disabled]:hover .icon,.button.button-violet-light.disabled:hover .icon,.button.button-violet-light[disabled]:active .icon,.button.button-violet-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-violet-light.button-square {padding: 8px 12px;}.button.button-violet-light.button-lg {padding: 6px 16px;}.button.button-violet-light.button-lg.button-square {padding: 6px 15px;}.button.button-violet-light.button-sm {padding: 4px 16px;}.button.button-violet-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-violet-light:hover {border-right-width: 0;}.button-group .button.button-violet-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-blue-light {background-color: #e1f3ff;background-image: none;border-color: #e1f3ff;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-blue-light .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light:visited {color: #555659;}.button.button-blue-light:hover,.button.button-blue-light.hover {background-color: #bfe5ff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light:hover .icon,.button.button-blue-light.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-blue-light:active,.button.button-blue-light.active {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light.selected {background-color: #a6daff;border-color: #e1f3ff;color: #555659;}.button.button-blue-light[disabled]:hover,.button.button-blue-light.disabled:hover,.button.button-blue-light[disabled]:active,.button.button-blue-light.disabled:active {background-color: #e1f3ff;background-image: none;color: #555659;}.button.button-blue-light[disabled]:hover .icon,.button.button-blue-light.disabled:hover .icon,.button.button-blue-light[disabled]:active .icon,.button.button-blue-light.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-blue-light.button-square {padding: 8px 12px;}.button.button-blue-light.button-lg {padding: 6px 16px;}.button.button-blue-light.button-lg.button-square {padding: 6px 15px;}.button.button-blue-light.button-sm {padding: 4px 16px;}.button.button-blue-light.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-blue-light:hover {border-right-width: 0;}.button-group .button.button-blue-light:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-turquoise {background-color: #1cadba;background-image: none;border-color: #1cadba;border-width: 0;color: #555659;padding: 8px 16px;}.button.button-turquoise .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise:visited {color: #555659;}.button.button-turquoise:hover,.button.button-turquoise.hover {background-color: #0097a6;border-color: #1cadba;color: #555659;}.button.button-turquoise:hover .icon,.button.button-turquoise.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-turquoise:active,.button.button-turquoise.active {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise.selected {background-color: #007580;border-color: #1cadba;color: #555659;}.button.button-turquoise[disabled]:hover,.button.button-turquoise.disabled:hover,.button.button-turquoise[disabled]:active,.button.button-turquoise.disabled:active {background-color: #1cadba;background-image: none;color: #555659;}.button.button-turquoise[disabled]:hover .icon,.button.button-turquoise.disabled:hover .icon,.button.button-turquoise[disabled]:active .icon,.button.button-turquoise.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-turquoise.button-square {padding: 8px 12px;}.button.button-turquoise.button-lg {padding: 6px 16px;}.button.button-turquoise.button-lg.button-square {padding: 6px 15px;}.button.button-turquoise.button-sm {padding: 4px 16px;}.button.button-turquoise.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-turquoise:hover {border-right-width: 0;}.button-group .button.button-turquoise:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-yellow {background-color: #ffa60d;background-image: none;border-color: #ffa60d;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-yellow .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow:visited {color: #fff;}.button.button-yellow:hover,.button.button-yellow.hover {background-color: #ff9000;border-color: #ffa60d;color: #fff;}.button.button-yellow:hover .icon,.button.button-yellow.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-yellow:active,.button.button-yellow.active {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow.selected {background-color: #e67600;border-color: #ffa60d;color: #fff;}.button.button-yellow[disabled]:hover,.button.button-yellow.disabled:hover,.button.button-yellow[disabled]:active,.button.button-yellow.disabled:active {background-color: #ffa60d;background-image: none;color: #fff;}.button.button-yellow[disabled]:hover .icon,.button.button-yellow.disabled:hover .icon,.button.button-yellow[disabled]:active .icon,.button.button-yellow.disabled:active .icon {opacity: 0.95;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=95)";filter: alpha(opacity=95);}.button.button-yellow.button-square {padding: 8px 12px;}.button.button-yellow.button-lg {padding: 6px 16px;}.button.button-yellow.button-lg.button-square {padding: 6px 15px;}.button.button-yellow.button-sm {padding: 4px 16px;}.button.button-yellow.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-yellow:hover {border-right-width: 0;}.button-group .button.button-yellow:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-black {background-color: #000;background-image: none;border-color: #000;border-width: 0;color: #fff;padding: 8px 16px;}.button.button-black .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black:visited {color: #fff;}.button.button-black:hover,.button.button-black.hover {background-color: #3b3d3f;border-color: #000;color: #fff;}.button.button-black:hover .icon,.button.button-black.hover .icon {opacity: 1;-ms-filter: none;filter: none;}.button.button-black:active,.button.button-black.active {background-color: #555659;border-color: #000;color: #fff;}.button.button-black.selected {background-color: #555659;border-color: #000;color: #fff;}.button.button-black[disabled]:hover,.button.button-black.disabled:hover,.button.button-black[disabled]:active,.button.button-black.disabled:active {background-color: #000;background-image: none;color: #fff;}.button.button-black[disabled]:hover .icon,.button.button-black.disabled:hover .icon,.button.button-black[disabled]:active .icon,.button.button-black.disabled:active .icon {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.button.button-black.button-square {padding: 8px 12px;}.button.button-black.button-lg {padding: 6px 16px;}.button.button-black.button-lg.button-square {padding: 6px 15px;}.button.button-black.button-sm {padding: 4px 16px;}.button.button-black.button-sm.button-square {padding: 4px 9px;}.button-group .button.button-black:hover {border-right-width: 0;}.button-group .button.button-black:hover + .button {margin-left: -1px;border-left-width: 1px;}.button.button-lg {border-radius: 3px;font-size: 18px;line-height: 36px;}.button.button-lg .icon,.momentum-body .button.button-lg .icon {height: 18px;width: 18px;}.button.button-sm {border-radius: 3px;font-size: 14px;line-height: 24px;}.button.button-sm .icon,.momentum-body .button.button-sm .icon {height: 14px;width: 14px;}.button-group {margin-right: 8px;}.button-group:last-child {margin-right: 0;}.button-group .button {border-radius: 0;margin-right: 0;}.button-group .button:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.button-group .button:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.button-group .button + .button {border-left-width: 1px;margin-left: -1px;}.button-circle {border-radius: 50%;background-color: #fff;border: 0;padding: 12px 0;color: #969799;height: 46px;width: 46px;line-height: 23px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.button-circle >.icon {height: 23px;width: 23px;margin: auto;}.button-circle:hover {color: #fff;background-color: #0c92f3;}.button-circle,a.button-circle {display: inline-block;background: #fff;}.button-circle,.momentum-body .button-circle {text-decoration: none;}.button-circle.button-shadow {-webkit-box-shadow: 0px 1px 4px rgba(0,0,0,0.25);box-shadow: 0px 1px 4px rgba(0,0,0,0.25);}.button-circle.button-circle-sm {height: 28px;width: 28px;line-height: 14px;padding: 6px 7px 6px 5px;}.button-circle.button-circle-sm >.icon {height: 14px;width: 14px;}.button-circle.button-circle-lg {height: 56px;width: 56px;line-height: 28px;padding: 13px 0;}.button-circle.button-circle-lg >.icon {height: 28px;width: 28px;}.card {background-color: #fff;border: 1px solid #f0f1f2;padding: 16px;width: 100%;}.centered-content {align-items: center;display: flex;justify-content: center;}.ol-chain-list {padding: 8px 16px;border-radius: 3px;}.ol-chain-list .ol-chain-separator:not(:last-child) {border-bottom: 1px solid #d7d7d9;border-color: #d7d7d9;}.ol-chain-list .ol-chain-link {position: relative;padding: 8px 0;margin-left: 40px;}.ol-chain-list .ol-chain-link:before {position: absolute;top: 8px;bottom: -8px;border-color: #d7d7d9;border-style: dashed;border-width: 0 0 0 1px;content: "";left: -28px;}.ol-chain-list .ol-chain-link:last-child:before {display: none;}.ol-chain-list .ol-chain-link .ol-chain-counter {border: 1px solid #d7d7d9;border-radius: 50%;}.ol-chain-list .ol-chain-link .ol-chain-icon {align-items: center;display: flex;justify-content: center;padding-bottom: 4px;padding-top: 4px;}.ol-chain-list .ol-chain-link .ol-chain-counter,.ol-chain-list .ol-chain-link .ol-chain-icon {position: absolute;left: -40px;width: 24px;height: 24px;background: #fff;text-align: center;font-size: 14px;}.ol-chain-list .ol-chain-link .ol-chain-counter.optional,.ol-chain-list .ol-chain-link .ol-chain-icon.optional {border: 1px dotted #d7d7d9;}.ol-chain-list .ol-chain-link .ol-chain-content {width: 70%;}.ol-chain-list .ol-chain-link .ol-chain-content-100 {width: 100%;}.ol-chain-list .ol-chain-link .ol-chain-content-distributed {display: flex;justify-content: space-between;}.chip {border-radius: 12px;border-style: solid;border-width: 1px;display: inline-block;font-size: 14px;line-height: 14px;height: 24px;margin: 1px 4px 3px;max-width: 100%;overflow: hidden;padding: 4px 7px;-o-text-overflow: ellipsis;text-overflow: ellipsis;-webkit-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-moz-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-o-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;-ms-transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;transition: border-color 0.10s ease-in-out, background-color 0.10s ease-in-out;vertical-align: middle;white-space: nowrap;}.chip,.momentum-body .chip {text-decoration: none;}.chip.chip-box {border-radius: 3px;}.chip:first-child {margin-left: 0;}.chip:last-child {margin-right: 0;}.chip + .chip {margin-left: 0;}.chip .icon {height: 1em;width: 1em;}.chip .icon,.chip .icon.momentum-body {margin-left: 0.5em;margin-right: 0.5em;}.chip > .close {color: inherit;}.chip > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 8px;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip > .close:hover {color: inherit;}.chip > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip > .close:active {color: inherit;}.chip > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip,.momentum-body  .chip {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}a.chip:hover,button.chip:hover,.chip.hover {background-color: #d7d7d9;border-color: #d7d7d9;color: #555659;}a.chip:active,button.chip:active,.chip.active {background-color: #b1b1b3;border-color: #b1b1b3;color: #555659;}a.chip:focus,button.chip:focus,.chip.focus {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip[disabled],.chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip[disabled]:hover,.chip.disabled:hover,.chip[disabled]:active,.chip.disabled:active {background-color: #e3e4e6;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined,.momentum-body  .chip.chip-outlined {background-color: #fff;border-color: #e3e4e6;color: #555659;}a.chip.chip-outlined:hover,button.chip.chip-outlined:hover,.chip.chip-outlined.hover {background-color: #f0f1f2;border-color: #d7d7d9;color: #555659;}a.chip.chip-outlined:active,button.chip.chip-outlined:active,.chip.chip-outlined.active {background-color: #e3e4e6;border-color: #b1b1b3;color: #555659;}a.chip.chip-outlined:focus,button.chip.chip-outlined:focus,.chip.chip-outlined.focus {background-color: #fff;border-color: #e3e4e6;color: #555659;}.chip.chip-outlined[disabled],.chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-outlined[disabled]:hover,.chip.chip-outlined.disabled:hover,.chip.chip-outlined[disabled]:active,.chip.chip-outlined.disabled:active {background-color: #fff;border-color: #e3e4e6;color: #555659;}.theme-inverse .chip,.momentum-body .theme-inverse .chip {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse a.chip:hover,.theme-inverse button.chip:hover,.theme-inverse .chip.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}.theme-inverse a.chip:active,.theme-inverse button.chip:active,.theme-inverse .chip.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip:focus,.theme-inverse button.chip:focus,.theme-inverse .chip.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip[disabled],.theme-inverse .chip.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip[disabled]:hover,.theme-inverse .chip.disabled:hover,.theme-inverse .chip[disabled]:active,.theme-inverse .chip.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.theme-inverse .chip.chip-outlined,.momentum-body .theme-inverse .chip.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse a.chip.chip-outlined:hover,.theme-inverse button.chip.chip-outlined:hover,.theme-inverse .chip.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:active,.theme-inverse button.chip.chip-outlined:active,.theme-inverse .chip.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}.theme-inverse a.chip.chip-outlined:focus,.theme-inverse button.chip.chip-outlined:focus,.theme-inverse .chip.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.theme-inverse .chip.chip-outlined[disabled],.theme-inverse .chip.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .chip.chip-outlined[disabled]:hover,.theme-inverse .chip.chip-outlined.disabled:hover,.theme-inverse .chip.chip-outlined[disabled]:active,.theme-inverse .chip.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse,.momentum-body  .chip.chip-inverse {background-color: #555659;border-color: #555659;color: #f0f1f2;}a.chip.chip-inverse:hover,button.chip.chip-inverse:hover,.chip.chip-inverse.hover {background-color: #707173;border-color: #707173;color: #f0f1f2;}a.chip.chip-inverse:active,button.chip.chip-inverse:active,.chip.chip-inverse.active {background-color: #969799;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse:focus,button.chip.chip-inverse:focus,.chip.chip-inverse.focus {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse[disabled],.chip.chip-inverse.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse[disabled]:hover,.chip.chip-inverse.disabled:hover,.chip.chip-inverse[disabled]:active,.chip.chip-inverse.disabled:active {background-color: #555659;border-color: #555659;color: #f0f1f2;}.chip.chip-inverse.chip-outlined,.momentum-body  .chip.chip-inverse.chip-outlined {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}a.chip.chip-inverse.chip-outlined:hover,button.chip.chip-inverse.chip-outlined:hover,.chip.chip-inverse.chip-outlined.hover {background-color: #555659;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:active,button.chip.chip-inverse.chip-outlined:active,.chip.chip-inverse.chip-outlined.active {background-color: #707173;border-color: #969799;color: #f0f1f2;}a.chip.chip-inverse.chip-outlined:focus,button.chip.chip-inverse.chip-outlined:focus,.chip.chip-inverse.chip-outlined.focus {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-inverse.chip-outlined[disabled],.chip.chip-inverse.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-inverse.chip-outlined[disabled]:hover,.chip.chip-inverse.chip-outlined.disabled:hover,.chip.chip-inverse.chip-outlined[disabled]:active,.chip.chip-inverse.chip-outlined.disabled:active {background-color: #3b3d3f;border-color: #969799;color: #d7d7d9;}.chip.chip-blue,.momentum-body  .chip.chip-blue {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}a.chip.chip-blue:hover,button.chip.chip-blue:hover,.chip.chip-blue.hover {background-color: #bfe5ff;border-color: #bfe5ff;color: #555659;}a.chip.chip-blue:active,button.chip.chip-blue:active,.chip.chip-blue.active {background-color: #a6daff;border-color: #a6daff;color: #555659;}a.chip.chip-blue:focus,button.chip.chip-blue:focus,.chip.chip-blue.focus {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue[disabled],.chip.chip-blue.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue[disabled]:hover,.chip.chip-blue.disabled:hover,.chip.chip-blue[disabled]:active,.chip.chip-blue.disabled:active {background-color: #e1f3ff;border-color: #e1f3ff;color: #555659;}.chip.chip-blue.chip-outlined,.momentum-body  .chip.chip-blue.chip-outlined {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:hover,button.chip.chip-blue.chip-outlined:hover,.chip.chip-blue.chip-outlined.hover {background-color: #bfe5ff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:active,button.chip.chip-blue.chip-outlined:active,.chip.chip-blue.chip-outlined.active {background-color: #a6daff;border-color: #0c92f3;color: #555659;}a.chip.chip-blue.chip-outlined:focus,button.chip.chip-blue.chip-outlined:focus,.chip.chip-blue.chip-outlined.focus {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue.chip-outlined[disabled],.chip.chip-blue.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue.chip-outlined[disabled]:hover,.chip.chip-blue.chip-outlined.disabled:hover,.chip.chip-blue.chip-outlined[disabled]:active,.chip.chip-blue.chip-outlined.disabled:active {background-color: #e1f3ff;border-color: #0c92f3;color: #555659;}.chip.chip-blue-dark,.momentum-body  .chip.chip-blue-dark {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}a.chip.chip-blue-dark:hover,button.chip.chip-blue-dark:hover,.chip.chip-blue-dark.hover {background-color: #0068b3;border-color: #0068b3;color: #f3faff;}a.chip.chip-blue-dark:active,button.chip.chip-blue-dark:active,.chip.chip-blue-dark.active {background-color: #004a7f;border-color: #004a7f;color: #f3faff;}a.chip.chip-blue-dark:focus,button.chip.chip-blue-dark:focus,.chip.chip-blue-dark.focus {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark[disabled],.chip.chip-blue-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark[disabled]:hover,.chip.chip-blue-dark.disabled:hover,.chip.chip-blue-dark[disabled]:active,.chip.chip-blue-dark.disabled:active {background-color: #007fd9;border-color: #007fd9;color: #f3faff;}.chip.chip-blue-dark.chip-outlined,.momentum-body  .chip.chip-blue-dark.chip-outlined {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:hover,button.chip.chip-blue-dark.chip-outlined:hover,.chip.chip-blue-dark.chip-outlined.hover {background-color: #0068b3;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:active,button.chip.chip-blue-dark.chip-outlined:active,.chip.chip-blue-dark.chip-outlined.active {background-color: #004a7f;border-color: #4cb5ff;color: #f3faff;}a.chip.chip-blue-dark.chip-outlined:focus,button.chip.chip-blue-dark.chip-outlined:focus,.chip.chip-blue-dark.chip-outlined.focus {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-blue-dark.chip-outlined[disabled],.chip.chip-blue-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-blue-dark.chip-outlined[disabled]:hover,.chip.chip-blue-dark.chip-outlined.disabled:hover,.chip.chip-blue-dark.chip-outlined[disabled]:active,.chip.chip-blue-dark.chip-outlined.disabled:active {background-color: #007fd9;border-color: #4cb5ff;color: #f3faff;}.chip.chip-red,.momentum-body  .chip.chip-red {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}a.chip.chip-red:hover,button.chip.chip-red:hover,.chip.chip-red.hover {background-color: #ffbfbf;border-color: #ffbfbf;color: #555659;}a.chip.chip-red:active,button.chip.chip-red:active,.chip.chip-red.active {background-color: #f99;border-color: #f99;color: #555659;}a.chip.chip-red:focus,button.chip.chip-red:focus,.chip.chip-red.focus {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red[disabled],.chip.chip-red.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red[disabled]:hover,.chip.chip-red.disabled:hover,.chip.chip-red[disabled]:active,.chip.chip-red.disabled:active {background-color: #ffe6e6;border-color: #ffe6e6;color: #555659;}.chip.chip-red.chip-outlined,.momentum-body  .chip.chip-red.chip-outlined {background-color: #ffe6e6;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:hover,button.chip.chip-red.chip-outlined:hover,.chip.chip-red.chip-outlined.hover {background-color: #ffbfbf;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:active,button.chip.chip-red.chip-outlined:active,.chip.chip-red.chip-outlined.active {background-color: #f99;border-color: #d94141;color: #555659;}a.chip.chip-red.chip-outlined:focus,button.chip.chip-red.chip-outlined:focus,.chip.chip-red.chip-outlined.focus {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red.chip-outlined[disabled],.chip.chip-red.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red.chip-outlined[disabled]:hover,.chip.chip-red.chip-outlined.disabled:hover,.chip.chip-red.chip-outlined[disabled]:active,.chip.chip-red.chip-outlined.disabled:active {background-color: #ffe6e6;border-color: #d94141;color: #555659;}.chip.chip-red-dark,.momentum-body  .chip.chip-red-dark {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}a.chip.chip-red-dark:hover,button.chip.chip-red-dark:hover,.chip.chip-red-dark.hover {background-color: #a62929;border-color: #a62929;color: #fff7f7;}a.chip.chip-red-dark:active,button.chip.chip-red-dark:active,.chip.chip-red-dark.active {background-color: #801a1a;border-color: #801a1a;color: #fff7f7;}a.chip.chip-red-dark:focus,button.chip.chip-red-dark:focus,.chip.chip-red-dark.focus {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark[disabled],.chip.chip-red-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark[disabled]:hover,.chip.chip-red-dark.disabled:hover,.chip.chip-red-dark[disabled]:active,.chip.chip-red-dark.disabled:active {background-color: #bf3939;border-color: #bf3939;color: #fff7f7;}.chip.chip-red-dark.chip-outlined,.momentum-body  .chip.chip-red-dark.chip-outlined {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:hover,button.chip.chip-red-dark.chip-outlined:hover,.chip.chip-red-dark.chip-outlined.hover {background-color: #a62929;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:active,button.chip.chip-red-dark.chip-outlined:active,.chip.chip-red-dark.chip-outlined.active {background-color: #801a1a;border-color: #f26161;color: #fff7f7;}a.chip.chip-red-dark.chip-outlined:focus,button.chip.chip-red-dark.chip-outlined:focus,.chip.chip-red-dark.chip-outlined.focus {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-red-dark.chip-outlined[disabled],.chip.chip-red-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-red-dark.chip-outlined[disabled]:hover,.chip.chip-red-dark.chip-outlined.disabled:hover,.chip.chip-red-dark.chip-outlined[disabled]:active,.chip.chip-red-dark.chip-outlined.disabled:active {background-color: #bf3939;border-color: #f26161;color: #fff7f7;}.chip.chip-green,.momentum-body  .chip.chip-green {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}a.chip.chip-green:hover,button.chip.chip-green:hover,.chip.chip-green.hover {background-color: #b4f0a8;border-color: #b4f0a8;color: #555659;}a.chip.chip-green:active,button.chip.chip-green:active,.chip.chip-green.active {background-color: #8ae58a;border-color: #8ae58a;color: #555659;}a.chip.chip-green:focus,button.chip.chip-green:focus,.chip.chip-green.focus {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green[disabled],.chip.chip-green.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green[disabled]:hover,.chip.chip-green.disabled:hover,.chip.chip-green[disabled]:active,.chip.chip-green.disabled:active {background-color: #d4f5c4;border-color: #d4f5c4;color: #555659;}.chip.chip-green.chip-outlined,.momentum-body  .chip.chip-green.chip-outlined {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:hover,button.chip.chip-green.chip-outlined:hover,.chip.chip-green.chip-outlined.hover {background-color: #b4f0a8;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:active,button.chip.chip-green.chip-outlined:active,.chip.chip-green.chip-outlined.active {background-color: #8ae58a;border-color: #39bf71;color: #555659;}a.chip.chip-green.chip-outlined:focus,button.chip.chip-green.chip-outlined:focus,.chip.chip-green.chip-outlined.focus {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green.chip-outlined[disabled],.chip.chip-green.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green.chip-outlined[disabled]:hover,.chip.chip-green.chip-outlined.disabled:hover,.chip.chip-green.chip-outlined[disabled]:active,.chip.chip-green.chip-outlined.disabled:active {background-color: #d4f5c4;border-color: #39bf71;color: #555659;}.chip.chip-green-dark,.momentum-body  .chip.chip-green-dark {background-color: #19a654;border-color: #19a654;color: #e1fae5;}a.chip.chip-green-dark:hover,button.chip.chip-green-dark:hover,.chip.chip-green-dark.hover {background-color: #0e8c42;border-color: #0e8c42;color: #e1fae5;}a.chip.chip-green-dark:active,button.chip.chip-green-dark:active,.chip.chip-green-dark.active {background-color: #007343;border-color: #007343;color: #e1fae5;}a.chip.chip-green-dark:focus,button.chip.chip-green-dark:focus,.chip.chip-green-dark.focus {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark[disabled],.chip.chip-green-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark[disabled]:hover,.chip.chip-green-dark.disabled:hover,.chip.chip-green-dark[disabled]:active,.chip.chip-green-dark.disabled:active {background-color: #19a654;border-color: #19a654;color: #e1fae5;}.chip.chip-green-dark.chip-outlined,.momentum-body  .chip.chip-green-dark.chip-outlined {background-color: #19a654;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:hover,button.chip.chip-green-dark.chip-outlined:hover,.chip.chip-green-dark.chip-outlined.hover {background-color: #0e8c42;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:active,button.chip.chip-green-dark.chip-outlined:active,.chip.chip-green-dark.chip-outlined.active {background-color: #007343;border-color: #61d086;color: #e1fae5;}a.chip.chip-green-dark.chip-outlined:focus,button.chip.chip-green-dark.chip-outlined:focus,.chip.chip-green-dark.chip-outlined.focus {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-green-dark.chip-outlined[disabled],.chip.chip-green-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-green-dark.chip-outlined[disabled]:hover,.chip.chip-green-dark.chip-outlined.disabled:hover,.chip.chip-green-dark.chip-outlined[disabled]:active,.chip.chip-green-dark.chip-outlined.disabled:active {background-color: #19a654;border-color: #61d086;color: #e1fae5;}.chip.chip-yellow,.momentum-body  .chip.chip-yellow {background-color: #fec;border-color: #fec;color: #555659;}a.chip.chip-yellow:hover,button.chip.chip-yellow:hover,.chip.chip-yellow.hover {background-color: #ffe5b2;border-color: #ffe5b2;color: #555659;}a.chip.chip-yellow:active,button.chip.chip-yellow:active,.chip.chip-yellow.active {background-color: #ffdf88;border-color: #ffdf88;color: #555659;}a.chip.chip-yellow:focus,button.chip.chip-yellow:focus,.chip.chip-yellow.focus {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow[disabled],.chip.chip-yellow.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow[disabled]:hover,.chip.chip-yellow.disabled:hover,.chip.chip-yellow[disabled]:active,.chip.chip-yellow.disabled:active {background-color: #fec;border-color: #fec;color: #555659;}.chip.chip-yellow.chip-outlined,.momentum-body  .chip.chip-yellow.chip-outlined {background-color: #fec;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:hover,button.chip.chip-yellow.chip-outlined:hover,.chip.chip-yellow.chip-outlined.hover {background-color: #ffe5b2;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:active,button.chip.chip-yellow.chip-outlined:active,.chip.chip-yellow.chip-outlined.active {background-color: #ffdf88;border-color: #ffa60d;color: #555659;}a.chip.chip-yellow.chip-outlined:focus,button.chip.chip-yellow.chip-outlined:focus,.chip.chip-yellow.chip-outlined.focus {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow.chip-outlined[disabled],.chip.chip-yellow.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow.chip-outlined[disabled]:hover,.chip.chip-yellow.chip-outlined.disabled:hover,.chip.chip-yellow.chip-outlined[disabled]:active,.chip.chip-yellow.chip-outlined.disabled:active {background-color: #fec;border-color: #ffa60d;color: #555659;}.chip.chip-yellow-dark,.momentum-body  .chip.chip-yellow-dark {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}a.chip.chip-yellow-dark:hover,button.chip.chip-yellow-dark:hover,.chip.chip-yellow-dark.hover {background-color: #e67600;border-color: #e67600;color: #fff6e5;}a.chip.chip-yellow-dark:active,button.chip.chip-yellow-dark:active,.chip.chip-yellow-dark.active {background-color: #cc5f00;border-color: #cc5f00;color: #fff6e5;}a.chip.chip-yellow-dark:focus,button.chip.chip-yellow-dark:focus,.chip.chip-yellow-dark.focus {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark[disabled],.chip.chip-yellow-dark.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark[disabled]:hover,.chip.chip-yellow-dark.disabled:hover,.chip.chip-yellow-dark[disabled]:active,.chip.chip-yellow-dark.disabled:active {background-color: #ff9000;border-color: #ff9000;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined,.momentum-body  .chip.chip-yellow-dark.chip-outlined {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:hover,button.chip.chip-yellow-dark.chip-outlined:hover,.chip.chip-yellow-dark.chip-outlined.hover {background-color: #e67600;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:active,button.chip.chip-yellow-dark.chip-outlined:active,.chip.chip-yellow-dark.chip-outlined.active {background-color: #cc5f00;border-color: #fb3;color: #fff6e5;}a.chip.chip-yellow-dark.chip-outlined:focus,button.chip.chip-yellow-dark.chip-outlined:focus,.chip.chip-yellow-dark.chip-outlined.focus {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-yellow-dark.chip-outlined[disabled],.chip.chip-yellow-dark.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-yellow-dark.chip-outlined[disabled]:hover,.chip.chip-yellow-dark.chip-outlined.disabled:hover,.chip.chip-yellow-dark.chip-outlined[disabled]:active,.chip.chip-yellow-dark.chip-outlined.disabled:active {background-color: #ff9000;border-color: #fb3;color: #fff6e5;}.chip.chip-violet,.momentum-body  .chip.chip-violet {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}a.chip.chip-violet:hover,button.chip.chip-violet:hover,.chip.chip-violet.hover {background-color: #ebc4ff;border-color: #ebc4ff;color: #555659;}a.chip.chip-violet:active,button.chip.chip-violet:active,.chip.chip-violet.active {background-color: #dea2fc;border-color: #dea2fc;color: #555659;}a.chip.chip-violet:focus,button.chip.chip-violet:focus,.chip.chip-violet.focus {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet[disabled],.chip.chip-violet.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet[disabled]:hover,.chip.chip-violet.disabled:hover,.chip.chip-violet[disabled]:active,.chip.chip-violet.disabled:active {background-color: #f5e0ff;border-color: #f5e0ff;color: #555659;}.chip.chip-violet.chip-outlined,.momentum-body  .chip.chip-violet.chip-outlined {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:hover,button.chip.chip-violet.chip-outlined:hover,.chip.chip-violet.chip-outlined.hover {background-color: #ebc4ff;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:active,button.chip.chip-violet.chip-outlined:active,.chip.chip-violet.chip-outlined.active {background-color: #dea2fc;border-color: #a452cc;color: #555659;}a.chip.chip-violet.chip-outlined:focus,button.chip.chip-violet.chip-outlined:focus,.chip.chip-violet.chip-outlined.focus {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-violet.chip-outlined[disabled],.chip.chip-violet.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-violet.chip-outlined[disabled]:hover,.chip.chip-violet.chip-outlined.disabled:hover,.chip.chip-violet.chip-outlined[disabled]:active,.chip.chip-violet.chip-outlined.disabled:active {background-color: #f5e0ff;border-color: #a452cc;color: #555659;}.chip.chip-turquoise,.momentum-body  .chip.chip-turquoise {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}a.chip.chip-turquoise:hover,button.chip.chip-turquoise:hover,.chip.chip-turquoise.hover {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise:active,button.chip.chip-turquoise:active,.chip.chip-turquoise.active {background-color: #91eaf2;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise:focus,button.chip.chip-turquoise:focus,.chip.chip-turquoise.focus {background-color: #b8f0f5;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise[disabled],.chip.chip-turquoise.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise[disabled]:hover,.chip.chip-turquoise.disabled:hover,.chip.chip-turquoise[disabled]:active,.chip.chip-turquoise.disabled:active {background-color: #d9f7fa;border-color: #d9f7fa;color: #222326;}.chip.chip-turquoise.chip-outlined,.momentum-body  .chip.chip-turquoise.chip-outlined {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}a.chip.chip-turquoise.chip-outlined:hover,button.chip.chip-turquoise.chip-outlined:hover,.chip.chip-turquoise.chip-outlined.hover {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}a.chip.chip-turquoise.chip-outlined:active,button.chip.chip-turquoise.chip-outlined:active,.chip.chip-turquoise.chip-outlined.active {background-color: #91eaf2;border-color: #33c0cd;color: #222326;}a.chip.chip-turquoise.chip-outlined:focus,button.chip.chip-turquoise.chip-outlined:focus,.chip.chip-turquoise.chip-outlined.focus {background-color: #b8f0f5;border-color: #91eaf2;color: #222326;}.chip.chip-turquoise.chip-outlined[disabled],.chip.chip-turquoise.chip-outlined.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.chip.chip-turquoise.chip-outlined[disabled]:hover,.chip.chip-turquoise.chip-outlined.disabled:hover,.chip.chip-turquoise.chip-outlined[disabled]:active,.chip.chip-turquoise.chip-outlined.disabled:active {background-color: #d9f7fa;border-color: #b8f0f5;color: #222326;}.chip.chip-turquoise.closable.closable-wide > .close::after {color: #555659;}.chip.chip-turquoise.closable.closable-wide > .close:hover::after {background-color: #91eaf2;}.chip.chip-turquoise.closable.closable-wide > .close:active::after {background-color: #33c0cd;}.chip.chip-lg {border-radius: 16px;font-size: 16px;height: 32px;line-height: 16px;padding: 7px 11px;}.chip.chip-lg.chip-box {border-radius: 3px;}.chip.chip-lg > .close::after {font-size: 13px;margin-left: 8px;}.chip.chip-sm {border-radius: 8px;font-size: 12px;height: 16px;line-height: 12px;padding: 1px 7px;}.chip.chip-sm.chip-box {border-radius: 3px;}.chip.chip-sm > .close::after {font-size: 9px;margin-left: 4px;}.chip.closable {padding-right: 20px;position: relative;}.chip.closable.closable-wide {align-items: center;display: inline-flex;padding-right: 8px;}.chip.closable.closable-wide > .close {position: relative;right: auto;}.chip.closable.closable-wide > .close::after {align-items: center;border-radius: 3px;display: inline-flex;justify-content: center;margin-left: 8px;opacity: 1;-ms-filter: none;filter: none;height: 16px;width: 16px;}.chip.closable.closable-wide > .close:hover::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide > .close:focus::after {opacity: 1;-ms-filter: none;filter: none;}.chip.closable.closable-wide.chip-lg {padding-right: 8px;}.chip.closable.closable-wide.chip-lg > .close::after {margin-left: 8px;height: 20px;width: 20px;}.chip.closable.closable-wide.chip-sm {padding-right: 4px;}.chip.closable.closable-wide.chip-sm > .close::after {margin-left: 4px;height: 12px;width: 12px;}.chip.closable > .close {color: inherit;position: absolute;right: 8px;text-decoration: none;}.chip.closable > .close::after {color: inherit;content: "✕";display: inline-block;font-size: 11px;margin-left: 0;opacity: 0.54;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=54)";filter: alpha(opacity=54);vertical-align: text-bottom;}.chip.closable > .close:hover {color: inherit;}.chip.closable > .close:hover::after {opacity: 0.75;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=75)";filter: alpha(opacity=75);}.chip.closable > .close:active {color: inherit;}.chip.closable > .close:active::after {opacity: 0.96;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=96)";filter: alpha(opacity=96);}.chip.closable.chip-lg {padding-right: 22px;}.chip.closable.chip-lg > .close::after {font-size: 13px;}.chip.closable.chip-sm {padding-right: 19px;}.chip.closable.chip-sm > .close::after {font-size: 9px;}.display-on-hover .displayed-on-hover {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.display-on-hover:hover .displayed-on-hover {opacity: 1;-ms-filter: none;filter: none;-webkit-transition: opacity 200ms ease-in-out;-moz-transition: opacity 200ms ease-in-out;-o-transition: opacity 200ms ease-in-out;-ms-transition: opacity 200ms ease-in-out;transition: opacity 200ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-fast {-webkit-transition: opacity 100ms ease-in-out;-moz-transition: opacity 100ms ease-in-out;-o-transition: opacity 100ms ease-in-out;-ms-transition: opacity 100ms ease-in-out;transition: opacity 100ms ease-in-out;}.display-on-hover:hover .displayed-on-hover.display-slow {-webkit-transition: opacity 500ms ease-in-out;-moz-transition: opacity 500ms ease-in-out;-o-transition: opacity 500ms ease-in-out;-ms-transition: opacity 500ms ease-in-out;transition: opacity 500ms ease-in-out;}.text-divider {display: flex;align-items: center;text-align: center;}.text-divider::before,.text-divider::after {content: '';flex: 1;border-bottom: 1px solid #e3e4e6;}.text-divider:not(:empty)::before {margin-right: 8px;}.text-divider:not(:empty)::after {margin-left: 8px;}.marginless-divider {border-bottom: 1px solid #e3e4e6;}.form-group {margin-bottom: 24px;}.form-group label {display: block;font-size: 16px;margin-bottom: 4px;color: #222326;line-height: 24px;}.form-control,.form-control[disabled]:hover,.form-control.disabled:hover,.form-control.form-control-outlined,.theme-inverse .form-control.form-control-outlined,.form-control.form-control-outlined[disabled]:hover,.theme-inverse .form-control.form-control-outlined[disabled]:hover,.form-control.form-control-outlined.disabled:hover,.theme-inverse .form-control.form-control-outlined.disabled:hover {background-color: #fff;border-color: #e3e4e6;color: #222326;}.form-control::placeholder,.form-control[disabled]:hover::placeholder,.form-control.disabled:hover::placeholder,.form-control.form-control-outlined::placeholder,.theme-inverse .form-control.form-control-outlined::placeholder,.form-control.form-control-outlined[disabled]:hover::placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover::placeholder,.form-control.form-control-outlined.disabled:hover::placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover::placeholder,.form-control .form-control-placeholder,.form-control[disabled]:hover .form-control-placeholder,.form-control.disabled:hover .form-control-placeholder,.form-control.form-control-outlined .form-control-placeholder,.theme-inverse .form-control.form-control-outlined .form-control-placeholder,.form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined[disabled]:hover .form-control-placeholder,.form-control.form-control-outlined.disabled:hover .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.disabled:hover .form-control-placeholder {color: #555659;}.form-control:hover,.form-control.hover,.form-control.form-control-transparent:hover,.form-control.form-control-transparent.hover,.form-control.form-control-outlined:hover,.theme-inverse .form-control.form-control-outlined:hover,.form-control.form-control-outlined.hover,.theme-inverse .form-control.form-control-outlined.hover {background-color: #fff;border-color: #b1b1b3;color: #222326;}.theme-inverse .form-control,.theme-inverse .form-control[disabled]:hover,.theme-inverse .form-control.disabled:hover {background-color: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);color: #d7d7d9;}.theme-inverse .form-control::placeholder,.theme-inverse .form-control[disabled]:hover::placeholder,.theme-inverse .form-control.disabled:hover::placeholder,.theme-inverse .form-control .form-control-placeholder,.theme-inverse .form-control[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.disabled:hover .form-control-placeholder {color: #b1b1b3;}.theme-inverse .form-control:hover,.theme-inverse .form-control.hover {background-color: rgba(215,215,217,0.4);border-color: rgba(215,215,217,0);color: #d7d7d9;}.form-control.invalid,.form-control.invalid[disabled]:hover,.form-control.invalid.disabled:hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.invalid::placeholder,.form-control.invalid[disabled]:hover::placeholder,.form-control.invalid.disabled:hover::placeholder,.form-control.invalid .form-control-placeholder,.form-control.invalid[disabled]:hover .form-control-placeholder,.form-control.invalid.disabled:hover .form-control-placeholder {color: #555659;}.form-control.invalid:hover,.form-control.invalid.hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid,.theme-inverse .form-control.invalid[disabled]:hover,.theme-inverse .form-control.invalid.disabled:hover {background-color: #ffe6e6;border-color: #d94141;color: #222326;}.theme-inverse .form-control.invalid::placeholder,.theme-inverse .form-control.invalid[disabled]:hover::placeholder,.theme-inverse .form-control.invalid.disabled:hover::placeholder,.theme-inverse .form-control.invalid .form-control-placeholder,.theme-inverse .form-control.invalid[disabled]:hover .form-control-placeholder,.theme-inverse .form-control.invalid.disabled:hover .form-control-placeholder {color: #f99;}.theme-inverse .form-control.invalid:hover,.theme-inverse .form-control.invalid.hover {background-color: #fff7f7;border-color: #d94141;color: #222326;}.form-control.form-control-transparent,.form-control.form-control-transparent[disabled]:hover,.form-control.form-control-transparent.disabled:hover {background-color: transparent;border-color: transparent;color: inherit;}.form-control:focus,.form-control.focus,.form-control.form-control-transparent:focus,.form-control.form-control-transparent.focus,.theme-inverse .form-control:focus,.theme-inverse .form-control.focus,.form-control.form-control-outlined:focus,.theme-inverse .form-control.form-control-outlined:focus,.form-control.form-control-outlined.focus,.theme-inverse .form-control.form-control-outlined.focus,.form-control.invalid:focus,.form-control.invalid.focus,.theme-inverse .form-control.invalid:focus,.theme-inverse .form-control.invalid.focus {background-color: #fff;border-color: #0c92f3;color: #222326;}.form-control:focus::placeholder,.form-control.focus::placeholder,.form-control.form-control-transparent:focus::placeholder,.form-control.form-control-transparent.focus::placeholder,.theme-inverse .form-control:focus::placeholder,.theme-inverse .form-control.focus::placeholder,.form-control.form-control-outlined:focus::placeholder,.theme-inverse .form-control.form-control-outlined:focus::placeholder,.form-control.form-control-outlined.focus::placeholder,.theme-inverse .form-control.form-control-outlined.focus::placeholder,.form-control.invalid:focus::placeholder,.form-control.invalid.focus::placeholder,.theme-inverse .form-control.invalid:focus::placeholder,.theme-inverse .form-control.invalid.focus::placeholder,.form-control:focus .form-control-placeholder,.form-control.focus .form-control-placeholder,.form-control.form-control-transparent:focus .form-control-placeholder,.form-control.form-control-transparent.focus .form-control-placeholder,.theme-inverse .form-control:focus .form-control-placeholder,.theme-inverse .form-control.focus .form-control-placeholder,.form-control.form-control-outlined:focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined:focus .form-control-placeholder,.form-control.form-control-outlined.focus .form-control-placeholder,.theme-inverse .form-control.form-control-outlined.focus .form-control-placeholder,.form-control.invalid:focus .form-control-placeholder,.form-control.invalid.focus .form-control-placeholder,.theme-inverse .form-control.invalid:focus .form-control-placeholder,.theme-inverse .form-control.invalid.focus .form-control-placeholder {color: #555659;}.form-control-label,label.form-control-label {display: block;line-height: 24px;font-size: 16px;margin-bottom: 4px;color: #222326;}.form-control-helper-text {display: block;margin-bottom: 4px;color: #222326;font-size: 14px;line-height: 21px;}.theme-inverse .form-group label,.theme-inverse .form-control-label,.theme-inverse label.form-control-label,.theme-inverse .form-control-helper-text {color: #d7d7d9;}.form-control {border-radius: 3px;border-style: solid;border-width: 1px;display: block;font-size: 16px;line-height: 24px;padding: 7px 15px;resize: vertical;-webkit-transition: border-color 0.15s ease-in-out;-moz-transition: border-color 0.15s ease-in-out;-o-transition: border-color 0.15s ease-in-out;-ms-transition: border-color 0.15s ease-in-out;transition: border-color 0.15s ease-in-out;width: 100%;}.form-control:focus,.form-control.focus {outline: 0;}.form-control[disabled],.form-control.disabled {cursor: default;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-control.multi-select-input {padding: 6px 15px;}input.form-control {height: 40px;}.form-control-inline {display: inline-block;width: auto;}.form-control-inherit {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;color: inherit;font-size: inherit;font-weight: inherit;line-height: inherit;margin: -1px -8px;padding: 0 7px;}.form-control-inherit,input.form-control-inherit {height: auto;}.form-control-inherit.form-control-inline {margin-left: 0;margin-right: 0;}.form-control-lg {border-radius: 3px;font-size: 32px;line-height: 40px;padding: 3px 15px;}input.form-control-lg {height: 48px;}.form-control-sm {border-radius: 3px;font-size: 14px;line-height: 21px;padding: 4.5px 15px;}.form-control-sm.multi-select-input {padding: 3.5px 15px;}input.form-control-sm {height: 32px;}.form-check {display: block;}.form-check + .form-check {margin-top: 8px;}.form-check.disabled,.form-check [disabled] {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-check-label {display: inline-block;min-height: 24px;padding-left: 24px;position: relative;vertical-align: top;}.form-check-label .form-text {margin-top: 0;}.form-group label.form-check-label {display: inline-block;margin-bottom: 0;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {-moz-appearance: none;-webkit-appearance: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;border-style: solid;border-width: 1px;display: inline-block;height: 16px;margin: 0;position: relative;vertical-align: -0.15em;width: 16px;}.form-check-input,input[type=checkbox].form-check-input,input[type=radio].form-check-input {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);}.form-check-input:hover,input[type=checkbox].form-check-input:hover,input[type=radio].form-check-input:hover,.form-check.hover .form-check-input,.form-check.hover input[type=checkbox].form-check-input,.form-check.hover input[type=radio].form-check-input {background: rgba(150,151,153,0.4);border-color: #b1b1b3;}.form-check-input:active,input[type=checkbox].form-check-input:active,input[type=radio].form-check-input:active,.form-check.active .form-check-input,.form-check.active input[type=checkbox].form-check-input,.form-check.active input[type=radio].form-check-input {background: rgba(112,113,115,0.4);border-color: #969799;}.form-check-input:checked,input[type=checkbox].form-check-input:checked,input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input:checked:hover,input[type=checkbox].form-check-input:checked:hover,input[type=radio].form-check-input:checked:hover,.form-check.hover .form-check-input:checked,.form-check.hover input[type=checkbox].form-check-input:checked,.form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.form-check-input:checked:active,input[type=checkbox].form-check-input:checked:active,input[type=radio].form-check-input:checked:active,.form-check.active .form-check-input:checked,.form-check.active input[type=checkbox].form-check-input:checked,.form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.form-check-input[disabled]:hover,input[type=checkbox].form-check-input[disabled]:hover,input[type=radio].form-check-input[disabled]:hover,.form-check-input:indeterminate:hover,input[type=checkbox].form-check-input:indeterminate:hover,input[type=radio].form-check-input:indeterminate:hover,.form-check.disabled .form-check-input:hover,.form-check.disabled input[type=checkbox].form-check-input:hover,.form-check.disabled input[type=radio].form-check-input:hover,.form-check-input[disabled]:active,input[type=checkbox].form-check-input[disabled]:active,input[type=radio].form-check-input[disabled]:active,.form-check-input:indeterminate:active,input[type=checkbox].form-check-input:indeterminate:active,input[type=radio].form-check-input:indeterminate:active,.form-check.disabled .form-check-input:active,.form-check.disabled input[type=checkbox].form-check-input:active,.form-check.disabled input[type=radio].form-check-input:active {background: rgba(177,177,179,0.4);border-color: rgba(177,177,179,0);cursor: default;}.form-check-input[disabled]:checked,input[type=checkbox].form-check-input[disabled]:checked,input[type=radio].form-check-input[disabled]:checked,.form-check-input:indeterminate:checked,input[type=checkbox].form-check-input:indeterminate:checked,input[type=radio].form-check-input:indeterminate:checked,.form-check.disabled .form-check-input:checked,.form-check.disabled input[type=checkbox].form-check-input:checked,.form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-label .form-check-input,.form-check-label input[type=checkbox].form-check-input,.form-check-label input[type=radio].form-check-input {left: 0;position: absolute;top: 3px;}.form-check-input:focus,input[type=checkbox].form-check-input:focus,input[type=radio].form-check-input:focus {outline: 0;}.theme-inverse .form-check-input,.theme-inverse input[type=checkbox].form-check-input,.theme-inverse input[type=radio].form-check-input {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;}.theme-inverse .form-check-input:hover,.theme-inverse input[type=checkbox].form-check-input:hover,.theme-inverse input[type=radio].form-check-input:hover,.theme-inverse .form-check.hover .form-check-input,.theme-inverse .form-check.hover input[type=checkbox].form-check-input,.theme-inverse .form-check.hover input[type=radio].form-check-input {background: $formCheckOutlinedHoverBackgroundInverse;border-color: $formCheckOutlinedHoverBorderColorInverse;}.theme-inverse .form-check-input:active,.theme-inverse input[type=checkbox].form-check-input:active,.theme-inverse input[type=radio].form-check-input:active,.theme-inverse .form-check.active .form-check-input,.theme-inverse .form-check.active input[type=checkbox].form-check-input,.theme-inverse .form-check.active input[type=radio].form-check-input {background: $formCheckOutlinedActiveBackgroundInverse;border-color: $formCheckOutlinedActiveBorderColorInverse;}.theme-inverse .form-check-input:checked,.theme-inverse input[type=checkbox].form-check-input:checked,.theme-inverse input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.theme-inverse .form-check-input:checked:hover,.theme-inverse input[type=checkbox].form-check-input:checked:hover,.theme-inverse input[type=radio].form-check-input:checked:hover,.theme-inverse .form-check.hover .form-check-input:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input:checked {background: #007fd9;}.theme-inverse .form-check-input:checked:active,.theme-inverse input[type=checkbox].form-check-input:checked:active,.theme-inverse input[type=radio].form-check-input:checked:active,.theme-inverse .form-check.active .form-check-input:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.active input[type=radio].form-check-input:checked {background: #0068b3;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0c92f3;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #007fd9;}.theme-inverse input[type=checkbox].form-check-input.form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input:indeterminate {background: #0068b3;}.theme-inverse .form-check-input[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input[disabled]:hover,.theme-inverse input[type=radio].form-check-input[disabled]:hover,.theme-inverse .form-check-input:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input:indeterminate:hover,.theme-inverse input[type=radio].form-check-input:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input:hover,.theme-inverse .form-check-input[disabled]:active,.theme-inverse input[type=checkbox].form-check-input[disabled]:active,.theme-inverse input[type=radio].form-check-input[disabled]:active,.theme-inverse .form-check-input:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input:indeterminate:active,.theme-inverse input[type=radio].form-check-input:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input:active {background: $formCheckOutlinedBackgroundInverse;border-color: $formCheckOutlinedBorderColorInverse;cursor: default;}.theme-inverse .form-check-input[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input[disabled]:checked,.theme-inverse input[type=radio].form-check-input[disabled]:checked,.theme-inverse .form-check-input:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input:indeterminate:checked,.theme-inverse input[type=radio].form-check-input:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined,input[type=checkbox].form-check-input.form-check-input-outlined,input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #e3e4e6;}.form-check-input.form-check-input-outlined:hover,input[type=checkbox].form-check-input.form-check-input-outlined:hover,input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check.hover .form-check-input.form-check-input-outlined,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined {background: #fff;border-color: #b1b1b3;}.form-check-input.form-check-input-outlined:active,input[type=checkbox].form-check-input.form-check-input-outlined:active,input[type=radio].form-check-input.form-check-input-outlined:active,.form-check.active .form-check-input.form-check-input-outlined,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined,.form-check.active input[type=radio].form-check-input.form-check-input-outlined {background: #f0f1f2;border-color: #969799;}.form-check-input.form-check-input-outlined:checked,input[type=checkbox].form-check-input.form-check-input-outlined:checked,input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-outlined:checked:hover,input[type=checkbox].form-check-input.form-check-input-outlined:checked:hover,input[type=radio].form-check-input.form-check-input-outlined:checked:hover,.form-check.hover .form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-outlined:checked {background: #007fd9;}.form-check-input.form-check-input-outlined:checked:active,input[type=checkbox].form-check-input.form-check-input-outlined:checked:active,input[type=radio].form-check-input.form-check-input-outlined:checked:active,.form-check.active .form-check-input.form-check-input-outlined:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.active input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0068b3;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0c92f3;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #007fd9;}input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-outlined:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-outlined:indeterminate {background: #0068b3;}.form-check-input.form-check-input-outlined[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:hover,input[type=radio].form-check-input.form-check-input-outlined[disabled]:hover,.form-check-input.form-check-input-outlined:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:hover,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:hover,.form-check-input.form-check-input-outlined[disabled]:active,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:active,input[type=radio].form-check-input.form-check-input-outlined[disabled]:active,.form-check-input.form-check-input-outlined:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:active,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:active {background: #fff;border-color: #e3e4e6;cursor: default;}.form-check-input.form-check-input-outlined[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-outlined[disabled]:checked,input[type=radio].form-check-input.form-check-input-outlined[disabled]:checked,.form-check-input.form-check-input-outlined:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-outlined:indeterminate:checked,input[type=radio].form-check-input.form-check-input-outlined:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-outlined:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-outlined:checked {background: #0c92f3;border-width: 0;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.4945L7.97802 2.21978L4.85714 3.27472V0H3.53846V3.27472L0.417582 2.21978L0 3.4945L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.4945Z' fill='%23B1B1B3'/%3E%3C/svg%3E%0A");padding: 3px;}.form-check-input.form-check-input-required,input[type=checkbox].form-check-input.form-check-input-required,input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:hover,input[type=checkbox].form-check-input.form-check-input-required:hover,input[type=radio].form-check-input.form-check-input-required:hover,.form-check.hover .form-check-input.form-check-input-required,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required,.form-check.hover input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:active,input[type=checkbox].form-check-input.form-check-input-required:active,input[type=radio].form-check-input.form-check-input-required:active,.form-check.active .form-check-input.form-check-input-required,.form-check.active input[type=checkbox].form-check-input.form-check-input-required,.form-check.active input[type=radio].form-check-input.form-check-input-required {background: ;border-color: ;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked:hover,input[type=checkbox].form-check-input.form-check-input-required:checked:hover,input[type=radio].form-check-input.form-check-input-required:checked:hover,.form-check.hover .form-check-input.form-check-input-required:checked,.form-check.hover input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.hover input[type=radio].form-check-input.form-check-input-required:checked {background: #d94141;}.form-check-input.form-check-input-required:checked:active,input[type=checkbox].form-check-input.form-check-input-required:checked:active,input[type=radio].form-check-input.form-check-input-required:checked:active,.form-check.active .form-check-input.form-check-input-required:checked,.form-check.active input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.active input[type=radio].form-check-input.form-check-input-required:checked {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #f26161;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #d94141;}input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.form-check-input-required:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.form-check-input-required:indeterminate {background: #bf3939;}.form-check-input.form-check-input-required[disabled]:hover,input[type=checkbox].form-check-input.form-check-input-required[disabled]:hover,input[type=radio].form-check-input.form-check-input-required[disabled]:hover,.form-check-input.form-check-input-required:indeterminate:hover,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:hover,input[type=radio].form-check-input.form-check-input-required:indeterminate:hover,.form-check.disabled .form-check-input.form-check-input-required:hover,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:hover,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:hover,.form-check-input.form-check-input-required[disabled]:active,input[type=checkbox].form-check-input.form-check-input-required[disabled]:active,input[type=radio].form-check-input.form-check-input-required[disabled]:active,.form-check-input.form-check-input-required:indeterminate:active,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:active,input[type=radio].form-check-input.form-check-input-required:indeterminate:active,.form-check.disabled .form-check-input.form-check-input-required:active,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:active,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:active {background: ;border-color: ;cursor: default;}.form-check-input.form-check-input-required[disabled]:checked,input[type=checkbox].form-check-input.form-check-input-required[disabled]:checked,input[type=radio].form-check-input.form-check-input-required[disabled]:checked,.form-check-input.form-check-input-required:indeterminate:checked,input[type=checkbox].form-check-input.form-check-input-required:indeterminate:checked,input[type=radio].form-check-input.form-check-input-required:indeterminate:checked,.form-check.disabled .form-check-input.form-check-input-required:checked,.form-check.disabled input[type=checkbox].form-check-input.form-check-input-required:checked,.form-check.disabled input[type=radio].form-check-input.form-check-input-required:checked {background: #f26161;border-width: 0;}.form-check-input.form-check-input-required:checked,input[type=checkbox].form-check-input.form-check-input-required:checked,input[type=radio].form-check-input.form-check-input-required:checked {content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='9' height='8' viewBox='0 0 9 8'%3E%3Cpath d='M8.39561 3.49451L7.97802 2.21978L4.85714 3.27473V0H3.53846V3.27473L0.417582 2.21978L0 3.49451L3.0989 4.54945L1.18681 7.16483L2.28571 8L4.1978 5.2967L6.17583 8L7.25275 7.16483L5.2967 4.54945L8.39561 3.49451Z' fill='white'/%3E%3C/svg%3E%0A");}.form-check-input.invalid,input[type=checkbox].form-check-input.invalid,input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.form-check-input.invalid:hover,input[type=checkbox].form-check-input.invalid:hover,input[type=radio].form-check-input.invalid:hover,.form-check.hover .form-check-input.invalid,.form-check.hover input[type=checkbox].form-check-input.invalid,.form-check.hover input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.form-check-input.invalid:active,input[type=checkbox].form-check-input.invalid:active,input[type=radio].form-check-input.invalid:active,.form-check.active .form-check-input.invalid,.form-check.active input[type=checkbox].form-check-input.invalid,.form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.form-check-input.invalid:checked,input[type=checkbox].form-check-input.invalid:checked,input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.form-check-input.invalid:checked:hover,input[type=checkbox].form-check-input.invalid:checked:hover,input[type=radio].form-check-input.invalid:checked:hover,.form-check.hover .form-check-input.invalid:checked,.form-check.hover input[type=checkbox].form-check-input.invalid:checked,.form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.form-check-input.invalid:checked:active,input[type=checkbox].form-check-input.invalid:checked:active,input[type=radio].form-check-input.invalid:checked:active,.form-check.active .form-check-input.invalid:checked,.form-check.active input[type=checkbox].form-check-input.invalid:checked,.form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.form-check-input.invalid[disabled]:hover,input[type=checkbox].form-check-input.invalid[disabled]:hover,input[type=radio].form-check-input.invalid[disabled]:hover,.form-check-input.invalid:indeterminate:hover,input[type=checkbox].form-check-input.invalid:indeterminate:hover,input[type=radio].form-check-input.invalid:indeterminate:hover,.form-check.disabled .form-check-input.invalid:hover,.form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.form-check.disabled input[type=radio].form-check-input.invalid:hover,.form-check-input.invalid[disabled]:active,input[type=checkbox].form-check-input.invalid[disabled]:active,input[type=radio].form-check-input.invalid[disabled]:active,.form-check-input.invalid:indeterminate:active,input[type=checkbox].form-check-input.invalid:indeterminate:active,input[type=radio].form-check-input.invalid:indeterminate:active,.form-check.disabled .form-check-input.invalid:active,.form-check.disabled input[type=checkbox].form-check-input.invalid:active,.form-check.disabled input[type=radio].form-check-input.invalid:active {background: #fff7f7;border-color: #d94141;cursor: default;}.form-check-input.invalid[disabled]:checked,input[type=checkbox].form-check-input.invalid[disabled]:checked,input[type=radio].form-check-input.invalid[disabled]:checked,.form-check-input.invalid:indeterminate:checked,input[type=checkbox].form-check-input.invalid:indeterminate:checked,input[type=radio].form-check-input.invalid:indeterminate:checked,.form-check.disabled .form-check-input.invalid:checked,.form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid,.theme-inverse input[type=checkbox].form-check-input.invalid,.theme-inverse input[type=radio].form-check-input.invalid {background: #ffe6e6;border-color: #d94141;}.theme-inverse .form-check-input.invalid:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:hover,.theme-inverse input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check.hover .form-check-input.invalid,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid {background: #fff7f7;border-color: #d94141;}.theme-inverse .form-check-input.invalid:active,.theme-inverse input[type=checkbox].form-check-input.invalid:active,.theme-inverse input[type=radio].form-check-input.invalid:active,.theme-inverse .form-check.active .form-check-input.invalid,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid {background: #ffbfbf;border-color: #d94141;}.theme-inverse .form-check-input.invalid:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:checked,.theme-inverse input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}.theme-inverse .form-check-input.invalid:checked:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:hover,.theme-inverse input[type=radio].form-check-input.invalid:checked:hover,.theme-inverse .form-check.hover .form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.hover input[type=radio].form-check-input.invalid:checked {background: #bf3939;}.theme-inverse .form-check-input.invalid:checked:active,.theme-inverse input[type=checkbox].form-check-input.invalid:checked:active,.theme-inverse input[type=radio].form-check-input.invalid:checked:active,.theme-inverse .form-check.active .form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.active input[type=radio].form-check-input.invalid:checked {background: #a62929;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #d94141;border-width: 0;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.hover input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.hover input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #bf3939;}.theme-inverse input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.active input[type=checkbox].form-check-input.form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=checkbox].form-check-input.invalid:indeterminate,.theme-inverse .form-check.active input[type=checkbox].form-check-inputinput[type=radio].form-check-input.invalid:indeterminate {background: #a62929;}.theme-inverse .form-check-input.invalid[disabled]:hover,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:hover,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:hover,.theme-inverse .form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:hover,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:hover,.theme-inverse .form-check.disabled .form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:hover,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:hover,.theme-inverse .form-check-input.invalid[disabled]:active,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:active,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:active,.theme-inverse .form-check-input.invalid:indeterminate:active,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:active,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:active,.theme-inverse .form-check.disabled .form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:active,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:active {background: #ffe6e6;border-color: #d94141;cursor: default;}.theme-inverse .form-check-input.invalid[disabled]:checked,.theme-inverse input[type=checkbox].form-check-input.invalid[disabled]:checked,.theme-inverse input[type=radio].form-check-input.invalid[disabled]:checked,.theme-inverse .form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=checkbox].form-check-input.invalid:indeterminate:checked,.theme-inverse input[type=radio].form-check-input.invalid:indeterminate:checked,.theme-inverse .form-check.disabled .form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=checkbox].form-check-input.invalid:checked,.theme-inverse .form-check.disabled input[type=radio].form-check-input.invalid:checked {background: #d94141;border-width: 0;}input[type=radio].form-check-input {border-radius: 8px;}input[type=radio].form-check-input:checked::after {background-color: #fff;border-radius: 3px;content: "";height: 6px;left: 5px;position: absolute;top: 5px;width: 6px;}input[type=checkbox].form-check-input {border-radius: 3px;}input[type=checkbox].form-check-input:indeterminate::after {border-bottom: 2px solid #fff;content: "";height: 4px;left: 26%;position: absolute;top: 20%;width: 7px;}input[type=checkbox].form-check-input:checked::after {border-bottom: 2px solid #fff;border-left: 2px solid #fff;content: "";height: 4px;left: 22%;position: absolute;top: 20%;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);width: 7px;}.form-check-inline {display: inline-block;}.form-check-inline + .form-check-inline {margin-left: 24px;margin-top: 0;}.col-form-label {font-size: 16px;line-height: 24px;margin-bottom: 0;padding-top: 8px;}.col-form-label-lg {font-size: 32px;line-height: 40px;padding-top: 4px;}.col-form-label-sm {font-size: 14px;line-height: 21px;padding-top: 5.5px;}.form-text {color: #555659;display: block;font-size: 14px;line-height: 21px;margin-top: 8px;}.form-text.invalid {color: #d94141;}.theme-inverse .form-text {color: #b1b1b3;}.theme-inverse .form-text.invalid {color: #f99;}.form-required::after {color: #d94141;content: "*";font-weight: normal;margin-left: 0.2em;}.chip.default-multi-select-input,.chip.small-multi-select-input {float: left;}.chip.default-multi-select-input {margin: 0.5px 4px 2px;}.chip.small-multi-select-input {margin: -1px 4px 1px;}.form-input-overlay {position: relative;}.form-input-overlay .overlay-front {left: 16px;position: absolute;top: 8px;}.form-input-overlay .overlay-front.overlay-sm {top: 4px;}.form-input-overlay .overlay-front.overlay-lg {top: 12px;}.form-input-overlay .overlay-back {position: absolute;right: 16px;top: 8px;}.form-input-overlay .overlay-back.overlay-sm {top: 4px;}.form-input-overlay .overlay-back.overlay-lg {top: 12px;}.form-input-overlay .form-control ~ .overlay-front,.form-input-overlay .form-control ~ .overlay-back {background-color: transparent;color: #222326;font-size: 16px;}.form-input-overlay .form-control:hover ~ .overlay-front,.form-input-overlay .form-control.hover ~ .overlay-front,.form-input-overlay .form-control:hover ~ .overlay-back,.form-input-overlay .form-control.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control:focus ~ .overlay-front,.form-input-overlay .form-control.focus ~ .overlay-front,.form-input-overlay .form-control:focus ~ .overlay-back,.form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control[disabled] ~ .overlay-front,.form-input-overlay .form-control.disabled ~ .overlay-front,.form-input-overlay .form-control[disabled] ~ .overlay-back,.form-input-overlay .form-control.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.form-input-overlay .form-control.form-control-transparent ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-transparent[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-transparent.disabled:hover ~ .overlay-back {color: inherit;}.form-input-overlay .form-control.form-control-inherit ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit ~ .overlay-back {color: inherit;font-size: inherit;font-weight: inherit;}.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-front,.form-input-overlay .form-control.form-control-inherit[disabled] ~ .overlay-back,.form-input-overlay .form-control.form-control-inherit.disabled ~ .overlay-back {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse .form-input-overlay .form-control ~ .overlay-front,.theme-inverse .form-input-overlay .form-control ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.hover ~ .overlay-back {color: #d7d7d9;}.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.disabled:hover ~ .overlay-back {color: #d7d7d9;}.form-input-overlay .form-control.form-control-outlined ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined:focus ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.form-control-outlined[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.form-control-outlined.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid ~ .overlay-front,.form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.hover ~ .overlay-front,.form-input-overlay .form-control.invalid:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid:focus ~ .overlay-front,.form-input-overlay .form-control.invalid.focus ~ .overlay-front,.form-input-overlay .form-control.invalid:focus ~ .overlay-back,.form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.hover ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid:focus ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.focus ~ .overlay-back {color: #222326;}.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-front,.theme-inverse .form-input-overlay .form-control.invalid[disabled]:hover ~ .overlay-back,.theme-inverse .form-input-overlay .form-control.invalid.disabled:hover ~ .overlay-back {color: #222326;}.form-input-overlay .overlay-input-left-sm {padding-left: 32px;}.form-input-overlay .overlay-input-right-sm {padding-right: 32px;}.form-input-overlay .overlay-input-both-sm {padding-left: 32px;padding-right: 32px;}.form-input-overlay .overlay-input-left-md {padding-left: 56px;}.form-input-overlay .overlay-input-right-md {padding-right: 56px;}.form-input-overlay .overlay-input-both-md {padding-left: 56px;padding-right: 56px;}.form-input-overlay .overlay-input-left-lg {padding-left: 80px;}.form-input-overlay .overlay-input-right-lg {padding-right: 80px;}.form-input-overlay .overlay-input-both-lg {padding-left: 80px;padding-right: 80px;}.form-input-overlay .overlay-input-left-icon {padding-left: 40px;}.form-input-overlay .overlay-input-right-icon {padding-right: 40px;}.form-input-overlay .overlay-input-both-icon {padding-left: 40px;padding-right: 40px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl,.col,.col-auto,.col-grow,.col-1,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-10,.col-11,.col-12,.col-sm,.col-sm-auto,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-md,.col-md-auto,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-lg,.col-lg-auto,.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-xl,.col-xl-auto,.col-xl-1,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9,.col-xl-10,.col-xl-11,.col-xl-12 {min-height: 1px;padding-left: 8px;padding-right: 8px;}.container-fluid,.container,.container-sm,.container-md,.container-lg,.container-xl {margin-left: auto;margin-right: auto;width: 100%;}.container {max-width: 100%;}.container-sm {max-width: 100%;}.container-md {max-width: 100%;}.container-lg {max-width: 100%;}.container-xl {max-width: 100%;}.row {display: flex;flex-wrap: wrap;margin-left: -8px;margin-right: -8px;}.row.no-gutters {margin-left: 0;margin-right: 0;}.row.no-gutters > .col,.row.no-gutters > [class*="col-"] {padding-left: 0;padding-right: 0;}a.row {text-decoration: none;}.col {flex: 1 1 0%;min-width: 0;width: 100%;}.col-auto {flex: 0 0 auto;width: auto;}.col-grow {flex: 1 0 auto;}.col-icon {align-items: center;display: flex;flex: 0 0 24px;}.col-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-3 {flex: 0 0 25%;max-width: 25%;}.col-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-6 {flex: 0 0 50%;max-width: 50%;}.col-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-9 {flex: 0 0 75%;max-width: 75%;}.col-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-12 {flex: 0 0 100%;max-width: 100%;}.mo-identicon {background-color: #e3e4e6;border-radius: 3px;color: #555659;display: inline-block;font-size: 12px;height: 24px;line-height: 24px;overflow: hidden;position: relative;text-align: center;text-decoration: none;vertical-align: middle;width: 24px;}.mo-identicon img {height: 100%;width: 100%;}.mo-identicon-initials {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;color: #fff;height: 100%;text-shadow: 0 0 2px rgba(0,0,0,0.2);width: 100%;}.mo-identicon-placeholder {background: -webkit-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -moz-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -o-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: -ms-linear-gradient(105deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;background: linear-gradient(-15deg, #969799, #969799 49%, #b1b1b3 51%, #b1b1b3) #969799;}.mo-identicon-placeholder .icon {color: #e3e4e6;height: 18px;width: 18px;}.mo-identicon-placeholder .icon,.momentum-body .mo-identicon-placeholder .icon {vertical-align: middle;}.mo-identicon-sm {font-size: 10px;height: 16px;line-height: 16px;width: 16px;}.mo-identicon-sm .mo-identicon-placeholder .icon {height: 12px;width: 12px;}.mo-identicon-lg {font-size: 14px;height: 32px;line-height: 32px;width: 32px;}.mo-identicon-lg .mo-identicon-placeholder .icon {height: 24px;width: 24px;}.mo-identicon-xl {font-size: 16px;height: 40px;line-height: 40px;width: 40px;}.mo-identicon-xl .mo-identicon-placeholder .icon {height: 30px;width: 30px;}.mo-identicon-initials-0 {background: -webkit-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -moz-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -o-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: -ms-linear-gradient(105deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;background: linear-gradient(-15deg, #59676c, #59676c 49%, #7c8f95 51%, #7c8f95) #59676c;}.mo-identicon-initials-1 {background: -webkit-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -moz-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -o-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: -ms-linear-gradient(105deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;background: linear-gradient(-15deg, #6c5c7e, #6c5c7e 49%, #9580af 51%, #9580af) #6c5c7e;}.mo-identicon-initials-2 {background: -webkit-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -moz-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -o-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: -ms-linear-gradient(105deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;background: linear-gradient(-15deg, #7e5756, #7e5756 49%, #ae7977 51%, #ae7977) #7e5756;}.mo-identicon-initials-3 {background: -webkit-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -moz-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -o-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: -ms-linear-gradient(105deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;background: linear-gradient(-15deg, #7e7156, #7e7156 49%, #af9d77 51%, #af9d77) #7e7156;}.mo-identicon-initials-4 {background: -webkit-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -moz-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -o-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: -ms-linear-gradient(105deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;background: linear-gradient(-15deg, #6a7e5c, #6a7e5c 49%, #93ae80 51%, #93ae80) #6a7e5c;}.mo-identicon-initials-5 {background: -webkit-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -moz-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -o-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: -ms-linear-gradient(105deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;background: linear-gradient(-15deg, #6a6a6a, #6a6a6a 49%, #939393 51%, #939393) #6a6a6a;}.mo-identicon-initials-6 {background: -webkit-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -moz-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -o-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: -ms-linear-gradient(105deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;background: linear-gradient(-15deg, #7e7e7f, #7e7e7f 49%, #afafb0 51%, #afafb0) #7e7e7f;}.mo-identicon-initials-7 {background: -webkit-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -moz-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -o-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: -ms-linear-gradient(105deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;background: linear-gradient(-15deg, #91828d, #91828d 49%, #c9b4c3 51%, #c9b4c3) #91828d;}.mo-identicon-initials-8 {background: -webkit-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -moz-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -o-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: -ms-linear-gradient(105deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;background: linear-gradient(-15deg, #92847b, #92847b 49%, #cab7aa 51%, #cab7aa) #92847b;}.mo-identicon-initials-9 {background: -webkit-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -moz-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -o-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: -ms-linear-gradient(105deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;background: linear-gradient(-15deg, #91917b, #91917b 49%, #c9c8aa 51%, #c9c8aa) #91917b;}.mo-identicon-initials-10 {background: -webkit-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -moz-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -o-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: -ms-linear-gradient(105deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;background: linear-gradient(-15deg, #829188, #829188 49%, #b4c9bc 51%, #b4c9bc) #829188;}.mo-identicon-initials-11 {background: -webkit-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -moz-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -o-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: -ms-linear-gradient(105deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;background: linear-gradient(-15deg, #735c6c, #735c6c 49%, #9f8096 51%, #9f8096) #735c6c;}.mo-identicon-initials-12 {background: -webkit-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -moz-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -o-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: -ms-linear-gradient(105deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;background: linear-gradient(-15deg, #a29692, #a29692 49%, #e0cfca 51%, #e0cfca) #a29692;}.mo-identicon-initials-13 {background: -webkit-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -moz-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -o-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: -ms-linear-gradient(105deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;background: linear-gradient(-15deg, #a66e8c, #a66e8c 49%, #e599c2 51%, #e599c2) #a66e8c;}.mo-identicon-initials-14 {background: -webkit-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -moz-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -o-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: -ms-linear-gradient(105deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;background: linear-gradient(-15deg, #b3745a, #b3745a 49%, #f8a17d 51%, #f8a17d) #b3745a;}.mo-identicon-initials-15 {background: -webkit-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -moz-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -o-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: -ms-linear-gradient(105deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;background: linear-gradient(-15deg, #8a8759, #8a8759 49%, #bfbb7b 51%, #bfbb7b) #8a8759;}.mo-identicon-initials-16 {background: -webkit-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -moz-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -o-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: -ms-linear-gradient(105deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;background: linear-gradient(-15deg, #755a49, #755a49 49%, #a27d66 51%, #a27d66) #755a49;}.mo-identicon-initials-17 {background: -webkit-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -moz-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -o-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: -ms-linear-gradient(105deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;background: linear-gradient(-15deg, #91534d, #91534d 49%, #c8736b 51%, #c8736b) #91534d;}.mo-identicon-initials-18 {background: -webkit-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -moz-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -o-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: -ms-linear-gradient(105deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;background: linear-gradient(-15deg, #4d8090, #4d8090 49%, #6bb1c7 51%, #6bb1c7) #4d8090;}.mo-identicon-initials-19 {background: -webkit-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -moz-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -o-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: -ms-linear-gradient(105deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;background: linear-gradient(-15deg, #49755f, #49755f 49%, #66a283 51%, #66a283) #49755f;}.mo-identicon-initials-20 {background: -webkit-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -moz-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -o-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: -ms-linear-gradient(105deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;background: linear-gradient(-15deg, #4a4f75, #4a4f75 49%, #676ea2 51%, #676ea2) #4a4f75;}.mo-identicon-initials-21 {background: -webkit-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -moz-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -o-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: -ms-linear-gradient(105deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;background: linear-gradient(-15deg, #78819e, #78819e 49%, #a6b2db 51%, #a6b2db) #78819e;}.mo-identicon-initials-22 {background: -webkit-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -moz-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -o-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: -ms-linear-gradient(105deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;background: linear-gradient(-15deg, #641c5f, #641c5f 49%, #8b2783 51%, #8b2783) #641c5f;}.mo-identicon-initials-23 {background: -webkit-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -moz-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -o-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: -ms-linear-gradient(105deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;background: linear-gradient(-15deg, #283774, #283774 49%, #384ca0 51%, #384ca0) #283774;}.mo-identicon-initials-24 {background: -webkit-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -moz-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -o-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: -ms-linear-gradient(105deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;background: linear-gradient(-15deg, #458a5e, #458a5e 49%, #60bf82 51%, #60bf82) #458a5e;}.mo-identicon-initials-25 {background: -webkit-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -moz-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -o-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: -ms-linear-gradient(105deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;background: linear-gradient(-15deg, #a7481a, #a7481a 49%, #e76425 51%, #e76425) #a7481a;}.mo-identicon-initials-26 {background: -webkit-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -moz-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -o-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: -ms-linear-gradient(105deg, #515151, #515151 49%, #707070 51%, #707070) #515151;background: linear-gradient(-15deg, #515151, #515151 49%, #707070 51%, #707070) #515151;}.mo-identicon-initials-27 {background: -webkit-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -moz-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -o-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: -ms-linear-gradient(105deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;background: linear-gradient(-15deg, #a31052, #a31052 49%, #e11772 51%, #e11772) #a31052;}.mo-identicon-initials-28 {background: -webkit-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -moz-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -o-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: -ms-linear-gradient(105deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;background: linear-gradient(-15deg, #0c4e67, #0c4e67 49%, #116c8f 51%, #116c8f) #0c4e67;}.mo-identicon-initials-29 {background: -webkit-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -moz-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -o-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: -ms-linear-gradient(105deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;background: linear-gradient(-15deg, #312269, #312269 49%, #442f91 51%, #442f91) #312269;}.mo-identicon-initials-30 {background: -webkit-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -moz-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -o-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: -ms-linear-gradient(105deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;background: linear-gradient(-15deg, #491b51, #491b51 49%, #652671 51%, #652671) #491b51;}.list-row {border-bottom: 1px solid #e3e4e6;border-top: 1px solid #e3e4e6;display: flex;flex-wrap: wrap;font-size: 16px;line-height: 24px;}.list-row + .list-row {margin-top: -1px;}.list-row > .col,.list-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.list-row.clickable:hover {background: #f0f1f2;cursor: pointer;}.list-row.clickable:active {background: #e3e4e6;}.list-row.clickable.selected {background: #f3faff;}.list-row.clickable.selected:hover {background: #e1f3ff;}.list-row.clickable.selected:active {background: #bfe5ff;}.list-row.hover,.list-row > .col.hover,.list-row > [class*="col-"].hover {background: #f0f1f2;}.list-row.active,.list-row > .col.active,.list-row > [class*="col-"].active {background: #e3e4e6;}.list-row.selected,.list-row > .col.selected,.list-row > [class*="col-"].selected {background: #f3faff;}.list-row.selected.hover,.list-row > .col.selected.hover,.list-row > [class*="col-"].selected.hover {background: #e1f3ff;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"] {text-decoration: none;}a.list-row,.momentum-body a.list-row,.list-row > a.col,.list-row > a[class*="col-"],a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover,a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active,a.list-row:visited,.momentum-body a.list-row:visited,.list-row > a.col:visited,.list-row > a[class*="col-"]:visited,.momentum-body .momentum-body a.list-row:visited,.momentum-body .list-row > a.col:visited,.momentum-body .list-row > a[class*="col-"]:visited {color: #222326;}a.list-row:hover,.momentum-body a.list-row:hover,.list-row > a.col:hover,.list-row > a[class*="col-"]:hover {background: #f0f1f2;}a.list-row:active,.momentum-body a.list-row:active,.list-row > a.col:active,.list-row > a[class*="col-"]:active {background: #e3e4e6;}a.list-row.selected:active,.momentum-body a.list-row.selected:active,.list-row > a.col.selected:active,.list-row > a[class*="col-"].selected:active {background: #bfe5ff;}a.list-row.selected.selected:hover,.momentum-body a.list-row.selected.selected:hover,.list-row > a.col.selected.selected:hover,.list-row > a[class*="col-"].selected.selected:hover {background: #e1f3ff;}.list-row > .col-form-label {padding-top: 16px;}.list-row > .col-form-label-lg {padding-top: 12px;}.list-row > .col-form-label-sm {padding-top: 13.5px;}.list-row-head {border-top: 0;}.col-list-row-header {align-self: flex-end;color: #969799;font-size: 12px;line-height: 18px;}.menu-row {display: flex;flex-wrap: wrap;font-size: 14px;line-height: 21px;padding-left: 8px;padding-right: 8px;}.menu-row h3,.menu-row h4 {margin-bottom: 0;}.menu-row h3,.menu-row .momentum-body h3,.menu-row .text-h3,.menu-row .text-h3_5 {font-size: 20px;line-height: 24px;}.menu-row .font-size-h3 {font-size: 20px;}.menu-row .line-height-h3 {line-height: 24px;}.menu-row h4,.menu-row .momentum-body h4,.menu-row .text-h4 {font-size: 16px;line-height: 24px;}.menu-row .font-size-h4 {font-size: 16px;}.menu-row .line-height-h4 {line-height: 24px;}.menu-row > .col,.menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.menu-row.hover {background: #f0f1f2;}.menu-row.active {background: #e3e4e6;}.menu-row.selected {background: #e1f3ff;}.menu-row.selected.hover {background: #bfe5ff;}.menu-row.selected.active {background: #a6daff;}.menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.menu-row {text-decoration: none;}a.menu-row:hover,a.menu-row:active,a.menu-row:visited {color: inherit;}a.menu-row:hover {background: #f0f1f2;}a.menu-row:active {background: #e3e4e6;}a.menu-row.selected:hover {background: #bfe5ff;}a.menu-row.selected:active {background: #a6daff;}.menu-divider {border-top: 1px solid #e3e4e6;margin-bottom: 4px;margin-top: 3px;}.message {color: #222326;background-color: #f0f1f2;border-radius: 3px;padding-bottom: 8px;padding-left: 40px;padding-right: 32px;padding-top: 8px;position: relative;}.message > .icon {position: absolute;left: 16px;top: 11px;}.message > .icon path {fill: #969799;}.message > p,.momentum-body .message > p {margin-bottom: 0;}.message > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;line-height: 16px;height: 16px;position: absolute;right: 16px;text-align: center;top: 11px;width: 16px;}.message > .close:hover::after {color: #555659;}.message > .close:active::after {color: #222326;}.message > .message-buttons {clear: left;float: right;margin-top: -4px;margin-right: -16px;padding-left: 4px;}.message > .message-buttons > .button-link {margin-top: 4px;}.message.message-info {background-color: #e1f3ff;}.message.message-info > .icon path {fill: #0c92f3;}.message.message-warning {background-color: #fec;}.message.message-warning > .icon path {fill: #ff9000;}.message.message-positive {background-color: #d4f5c4;}.message.message-positive > .icon path {fill: #39bf71;}.message.message-negative {background-color: #ffe6e6;}.message.message-negative > .icon path {fill: #d94141;}.message.message-gray {background-color: #f0f1f2;}.message.message-blue {background-color: #e1f3ff;}.message.message-red {background-color: #ffe6e6;}.message.message-green {background-color: #d4f5c4;}.message.message-yellow {background-color: #fec;}.message.message-rose {background-color: #ffe0f0;}.message.message-violet {background-color: #f5e0ff;}.message.message-turquoise {background-color: #d9f7fa;}.message.message-striped-red {background: -webkit-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -moz-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -o-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: -ms-repeating-linear-gradient(345deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);background: repeating-linear-gradient(105deg, #ffeded, #ffeded 6px, #fff5f5 6px, #fff5f5 12px);}.message.message-striped-blue {background: -webkit-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -moz-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -o-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: -ms-repeating-linear-gradient(345deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);background: repeating-linear-gradient(105deg, #eaf7ff, #eaf7ff 6px, #f2faff 6px, #f2faff 12px);}.message.message-striped-green {background: -webkit-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -moz-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -o-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: -ms-repeating-linear-gradient(345deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);background: repeating-linear-gradient(105deg, #e1f8d6, #e1f8d6 6px, #edfbe6 6px, #edfbe6 12px);}.message.message-inverse {background-color: #555659;color: #fff;}.message.message-inverse > .icon path {fill: #b1b1b3;}.message.message-inverse > .close::after {color: #969799;}.message.message-inverse > .close:hover::after {color: #b1b1b3;}.message.message-inverse > .close:active::after {color: #707173;}.message.message-compact {padding-top: 4px;padding-bottom: 4px;}.message.message-compact > .icon {top: 8.125px;}.message.message-compact > .close::after {top: 8.125px;}.message.message-compact > .message-buttons {margin-top: -5.5px;}.message.message-compact > .message-buttons > .button-link {margin-top: 5.5px;}.modal-backdrop {background-color: rgba(0,0,0,0.3);bottom: 0;display: none;left: 0;position: absolute;right: 0;top: 0;width: 100%;}.modal-backdrop.show {display: flex;}.modal {background: #fff;border-radius: 3px;display: flex;flex-direction: column;left: 0;margin: 0 auto;max-height: calc(100% - 96px);max-width: 640px;min-width: 480px;position: absolute;right: 0;top: 80px;}.modal-content {display: flex;flex-direction: column;height: 100%;overflow: auto;padding: 0 32px;}.modal-content.no-padding {padding: 0;}.modal-actions {align-items: flex-end;display: flex;flex: auto;justify-content: flex-end;padding: 24px 32px;}.modal-actions-distributed {align-items: flex-end;display: flex;flex: auto;justify-content: space-between;padding: 32px 32px;}.modal-navigation {height: auto;padding: 24px 32px 24px 32px;position: relative;}.modal-navigation.no-padding {padding: 0;}.modal-close {color: #555659;position: absolute;right: 16px;top: 16px;}.nav-link,.momentum-body .nav-link {color: $navLinkColor;font-size: $navLinkFontSize;text-decoration: none;}.nav-link:hover,.momentum-body .nav-link:hover {color: $navLinkHoverColor;text-decoration: underline;}.nav-link:active,.momentum-body .nav-link:active {color: $navLinkActiveColor;text-decoration: underline;}.nav-link > .icon {margin-left: 4px;margin-right: 4px;}.nav-link > .icon:first-child {margin-left: 0;}.nav-link > .icon:last-child {margin-right: 0;}.progress-bar .bar,.progress-bar .bar-interactive {align-items: center;border-radius: 3px;display: flex;height: 16px;justify-content: center;-webkit-transition: width 350ms ease-out;-moz-transition: width 350ms ease-out;-o-transition: width 350ms ease-out;-ms-transition: width 350ms ease-out;transition: width 350ms ease-out;}.progress-bar {align-items: center;border-radius: 3px;display: flex;}.progress-bar .bar-container {align-content: center;align-items: center;display: flex;padding: 0;width: 100%;justify-content: space-between;position: relative;}.progress-bar .bar-interactive:hover {cursor: pointer;}.progress-bar .bar-progress-text {display: flex;font-size: 12px;line-height: 12px;position: absolute;padding: 0 0 0 4px;}.progress-bar .bar-progress-text-inverted {position: static;}.progress-bar .bar-title {margin-right: 8px;text-transform: capitalize;}.score {background-color: #555659;border-radius: 3px;color: #fff;display: inline-block;font-size: 16px;height: 24px;line-height: 24px;overflow: hidden;text-align: center;vertical-align: middle;width: 24px;}.score .icon {height: 16px;width: 16px;}.score .mo-identicon {border-radius: 0;vertical-align: unset;}.score.score-worst {background-color: #555659;color: #d7d7d9;}.score.score-bad {background-color: #555659;color: #b1b1b3;}.score.score-good {background-color: #555659;color: #61d086;}.score.score-best {background-color: #555659;color: #8ae58a;}.score.score-unknown {background-color: #e3e4e6;color: #555659;}.score.score-sm {font-size: 12px;height: 16px;line-height: 16px;width: 16px;}.score.score-sm .icon {height: 12px;width: 12px;}.score.score-lg {font-size: 20px;height: 32px;line-height: 32px;width: 32px;}.score.score-lg .icon {height: 20px;width: 20px;}.score.score-xl {font-size: 24px;height: 40px;line-height: 40px;width: 40px;}.score.score-xl .icon {height: 24px;width: 24px;}.score-group {display: inline-block;}.score-group .score {border-radius: 0;}.score-group .score:first-child {border-bottom-left-radius: 3px;border-top-left-radius: 3px;}.score-group .score:last-child {border-bottom-right-radius: 3px;border-top-right-radius: 3px;}.arrow {position: relative;}.arrow .line,.arrow .line::after {height: 40px;}.arrow .line {display: block;text-align: center;}.arrow .line::after {position: absolute;background: #b1b1b3;content: ' ';margin-left: -1px;width: 2px;}.arrow .arrow-overlay {position: absolute;top: 50%;left: 50%;-webkit-transform: translate(-50%, -50%);-moz-transform: translate(-50%, -50%);-o-transform: translate(-50%, -50%);-ms-transform: translate(-50%, -50%);transform: translate(-50%, -50%);}.arrow.direction-down .arrow-head,.arrow.direction-up .arrow-head {width: 10px;height: 10px;position: absolute;left: calc(50% - 5px);}.arrow.direction-down .arrow-head::after,.arrow.direction-up .arrow-head::after {display: block;position: absolute;content: '';height: 10px;margin: 0;padding: 0;width: 10px;-webkit-box-shadow: inset -2px 2px 0 0 #b1b1b3;box-shadow: inset -2px 2px 0 0 #b1b1b3;}.arrow.direction-up .arrow-head {top: 0;}.arrow.direction-up .arrow-head::after {-moz-transform: rotate(-45deg);-ms-transform: rotate(-45deg);-o-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.arrow.direction-down .arrow-head {bottom: 0;}.arrow.direction-down .arrow-head::after {-moz-transform: rotate(135deg);-ms-transform: rotate(135deg);-o-transform: rotate(135deg);-webkit-transform: rotate(135deg);-webkit-transform: rotate(135deg);-moz-transform: rotate(135deg);-o-transform: rotate(135deg);-ms-transform: rotate(135deg);transform: rotate(135deg);}.arrow.length-long .line,.arrow.length-long .line::after {height: 72px;}.animation-shimmer {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -moz-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -o-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: -ms-linear-gradient(left, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-image: linear-gradient(to right, #f9f9f9 0, #f0f1f2 20%, #f9f9f9 40%, #f9f9f9 100%);background-size: 1000px 100%;}.animation-shimmer-inverse {-webkit-animation: shimmer 3s infinite linear;-moz-animation: shimmer 3s infinite linear;-o-animation: shimmer 3s infinite linear;-ms-animation: shimmer 3s infinite linear;animation: shimmer 3s infinite linear;background-image: -webkit-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -moz-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -o-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: -ms-linear-gradient(left, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-image: linear-gradient(to right, #707173 0, #555659 20%, #707173 40%, #707173 100%);background-size: 1000px 100%;}@-moz-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-webkit-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@-o-keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}@keyframes shimmer {0% {background-position: -1000px 0;}100% {background-position: 1000px 0;}}.sidebar-menu {background-color: #f9f9f9;height: 100%;overflow-y: auto;width: 304px;}.sidebar-menu-width {width: 304px;}.sidebar-menu-row {color: #969799;display: flex;flex-wrap: wrap;padding-left: 16px;padding-right: 16px;}.sidebar-menu-row h4,.sidebar-menu-row h3 {margin-bottom: 0;}.sidebar-menu-row > .col,.sidebar-menu-row > [class*="col-"] {padding-bottom: 8px;padding-top: 8px;}.sidebar-menu-row.hover {background: #fff;}.sidebar-menu-row.active {background: #e1f3ff;}.sidebar-menu-row.selected {color: #555659;background: #fff;border-left: 4px solid #0c92f3;padding-left: 12px;}.sidebar-menu-row.selected.hover {background: #f3faff;}.sidebar-menu-row.selected.active {background: #e1f3ff;}.sidebar-menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}a.sidebar-menu-row {color: #969799;text-decoration: none;}a.sidebar-menu-row:hover,a.sidebar-menu-row:active,a.sidebar-menu-row:visited {color: inherit;}a.sidebar-menu-row:hover {background: #fff;}a.sidebar-menu-row.selected {color: #555659;}a.sidebar-menu-row.selected:hover {background: #f3faff;}a.sidebar-menu-row.selected:active {background: #e1f3ff;}.sidebar-button-menu {width: 64px;height: 100%;overflow-y: auto;background-color: #f9f9f9;display: flex;flex-direction: column;align-items: center;}.sidebar-button-menu .sidebar-button-menu-row {margin-bottom: 8px;}.sidebar-button-menu .sidebar-button-menu-row .button {border: none;background-color: unset;background-image: unset;}.sidebar-button-menu .sidebar-button-menu-row:hover {margin-bottom: 6px;}.sidebar-button-menu .sidebar-button-menu-row:hover .button {-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);border-bottom: 2px solid #0c92f3;}.sidebar-button-menu .sidebar-button-menu-row.selected .button {background-color: #fff;-webkit-box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);box-shadow: 0 0 10px 0 rgba(0,0,0,0.15);}.tab-links,.tab-links-border-bottom {display: flex;}.tab-link {border-bottom: 4px solid transparent;color: #969799;cursor: pointer;margin-left: 8px;margin-right: 8px;padding-bottom: 8px;}.tab-link:first-child {margin-left: 0;}.tab-link:last-child {margin-right: 0;}.tab-link,.momentum-body a.tab-link {text-decoration: none;color: #969799;}.tab-link:hover,.momentum-body a.tab-link:hover,.tab-link.hover,.momentum-body a.tab-link.hover {color: #707173;border-bottom-color: #b1b1b3;}.tab-link:active,.momentum-body a.tab-link:active {border-bottom-color: #969799;}.tab-link.selected,.momentum-body a.tab-link.selected {border-bottom-color: #0c92f3;color: #555659;}.tab-links-border-bottom {border-bottom: 1px solid #e3e4e6;}.tab-links-border-bottom .tab-link {margin-bottom: -1px;margin-left: 0;margin-right: 0;padding-left: 8px;padding-right: 8px;}.tabs {border-bottom: 1px solid #e3e4e6;display: flex;}.tab {border-color: #e3e4e6;border-style: solid;border-top-left-radius: 3px;border-top-right-radius: 3px;border-width: 1px;cursor: pointer;margin-bottom: -1px;margin-left: 8px;margin-right: 8px;padding: 8px 16px;text-align: center;}.tab:first-child {margin-left: 0;}.tab:last-child {margin-right: 0;}.tab,.momentum-body a.tab {background-color: #fff;color: #969799;text-decoration: none;}.tab:hover,.momentum-body a.tab:hover,.tab.hover,.momentum-body a.tab.hover {color: #707173;}.tab.selected,.momentum-body a.tab.selected {border-bottom-color: #fff;color: #555659;}.toast {-webkit-animation: toastFadeIn 0.3s ease-out;-moz-animation: toastFadeIn 0.3s ease-out;-o-animation: toastFadeIn 0.3s ease-out;-ms-animation: toastFadeIn 0.3s ease-out;animation: toastFadeIn 0.3s ease-out;border-left: 4px solid #969799;border-radius: 3px;display: inline-block;max-width: 480px;padding-bottom: 8px;padding-left: 48px;padding-right: 48px;padding-top: 8px;position: relative;}.toast > .icon {color: #555659;left: 16px;position: absolute;top: 12px;}.toast > .close::after {color: #969799;content: "✕";display: block;font-size: 12px;height: 16px;line-height: 16px;position: absolute;right: 16px;text-align: center;top: 12px;width: 16px;}.toast > .close:hover::after {color: #555659;}.toast > .close:active::after {color: #222326;}.toast > .toast-buttons {margin-bottom: 8px;margin-top: 16px;}.toast.toast-info {border-left-color: #0c92f3;}.toast.toast-warning {border-left-color: #ffa60d;}.toast.toast-positive {border-left-color: #39bf71;}.toast.toast-negative {border-left-color: #d94141;}.toast.theme-inverse > .icon {color: #969799;}.toast.theme-inverse > .close::after {color: #969799;}.toast.theme-inverse > .close:hover::after {color: #b1b1b3;}.toast.theme-inverse > .close:active::after {color: #707173;}@-moz-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-webkit-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@-o-keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}@keyframes toastFadeIn {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);-webkit-transform: translateX(-8px);-moz-transform: translateX(-8px);-o-transform: translateX(-8px);-ms-transform: translateX(-8px);transform: translateX(-8px);}100% {opacity: 1;-ms-filter: none;filter: none;-webkit-transform: translateX(0);-moz-transform: translateX(0);-o-transform: translateX(0);-ms-transform: translateX(0);transform: translateX(0);}}.toggle {color: rgba(85,86,89,0.7);background-color: rgba(177,177,179,0.4);border-radius: 11px;border-width: 0;cursor: pointer;display: inline-block;height: 22px;margin: 1px 8px;padding: 0;position: relative;-webkit-transition: background-color 0.15s ease-in;-moz-transition: background-color 0.15s ease-in;-o-transition: background-color 0.15s ease-in;-ms-transition: background-color 0.15s ease-in;transition: background-color 0.15s ease-in;vertical-align: top;width: 40px;}.toggle:hover,.toggle.hover {background-color: rgba(177,177,179,0.6);}.toggle:active,.toggle.active {background-color: #b1b1b3;}.toggle:focus,.toggle.focus {outline: none;}.toggle[disabled],.toggle.disabled {background-color: rgba(177,177,179,0.4);}.toggle:first-child {margin-left: 0;}.toggle:last-child {margin-right: 0;}.toggle::after {background-color: #fff;border-radius: 8px;content: " ";display: block;height: 16px;left: 3px;top: 3px;position: absolute;-webkit-transition: left 0.15s linear;-moz-transition: left 0.15s linear;-o-transition: left 0.15s linear;-ms-transition: left 0.15s linear;transition: left 0.15s linear;width: 16px;}.toggle .icon,.momentum-body .toggle .icon {position: absolute;height: 12px;width: 12px;left: 23px;top: 5px;}.toggle.selected {color: rgba(255,255,255,0.7);background-color: #0c92f3;}.toggle.selected:hover,.toggle.selected.hover {background-color: #007fd9;}.toggle.selected:active,.toggle.selected.active {background-color: #0068b3;}.toggle.selected:focus,.toggle.selected.focus {outline: none;}.toggle.selected[disabled],.toggle.selected.disabled {background-color: #0c92f3;}.toggle.selected::after {left: 21px;}.toggle.selected .icon,.momentum-body .toggle.selected .icon {left: 5px;}.toggle.disabled {cursor: default;pointer-events: none;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.toggle.toggle-yellow.selected {color: rgba(255,255,255,0.7);background-color: #fb3;}.toggle.toggle-yellow.selected:hover,.toggle.toggle-yellow.selected.hover {background-color: #ffa60d;}.toggle.toggle-yellow.selected:active,.toggle.toggle-yellow.selected.active {background-color: #ff9000;}.toggle.toggle-yellow.selected:focus,.toggle.toggle-yellow.selected.focus {outline: none;}.toggle.toggle-yellow.selected[disabled],.toggle.toggle-yellow.selected.disabled {background-color: #fb3;}.toggle-lg {border-radius: 14px;height: 28px;width: 48px;margin-top: 4px;margin-bottom: 4px;}.toggle-lg::after {border-radius: 10px;height: 20px;left: 4px;top: 4px;width: 20px;}.toggle-lg .icon,.momentum-body .toggle-lg .icon {height: 16px;width: 16px;left: 26px;top: 6px;}.toggle-lg.selected::after {left: 24px;}.toggle-lg.selected .icon,.momentum-body .toggle-lg.selected .icon {left: 6px;}.toggle-sm {border-radius: 8px;height: 16px;width: 32px;margin-top: 2.5px;margin-bottom: 2.5px;}.toggle-sm::after {border-radius: 6px;height: 12px;left: 2px;top: 2px;width: 12px;}.toggle-sm .icon,.momentum-body .toggle-sm .icon {height: 9px;width: 9px;left: 19.5px;top: 3.5px;}.toggle-sm.selected::after {left: 18px;}.toggle-sm.selected .icon,.momentum-body .toggle-sm.selected .icon {left: 3.5px;}.text-h1 {font-size: 40px;font-weight: bold;line-height: 48px;}.text-h2 {font-size: 32px;font-weight: bold;line-height: 40px;}.text-h3 {font-size: 24px;font-weight: bold;line-height: 36px;}.text-h3_5 {font-size: 20px;font-weight: bold;line-height: 24px;}.text-h4 {font-size: 16px;font-weight: bold;line-height: 24px;}.text-h5 {font-size: 14px;font-weight: bold;line-height: 21px;}.text-base {font-size: 16px;font-weight: normal;line-height: 24px;}.text-small {font-size: 14px;font-weight: normal;line-height: 21px;}.text-caption {font-size: 12px;font-weight: normal;line-height: 18px;}.font-size-h1 {font-size: 40px;}.font-size-h2 {font-size: 32px;}.font-size-h3 {font-size: 24px;}.font-size-h3_5 {font-size: 20px;}.font-size-h4 {font-size: 16px;}.font-size-base {font-size: 16px;}.font-size-small {font-size: 14px;}.font-size-caption {font-size: 12px;}.line-height-h1 {line-height: 48px;}.line-height-h2 {line-height: 40px;}.line-height-h3 {line-height: 36px;}.line-height-h3_5 {line-height: 24px;}.line-height-h4 {line-height: 24px;}.line-height-base {line-height: 24px;}.line-height-small {line-height: 21px;}.line-height-caption {line-height: 18px;}.text-color-heading {color: #222326;}.text-color-body {color: #222326;}.text-muted {color: #555659;}.text-positive {color: #19a654;}.text-muted-positive {color: #61d086;}.text-negative {color: #d94141;}.text-muted-negative {color: #f99;}.upload {align-items: center;background-color: #fff;border: 2px #d7d7d9;border-style: dashed;color: #969799;cursor: pointer;display: flex;flex-direction: column;justify-content: center;padding: 8px;position: relative;}.upload:hover,.upload.hover {background-color: #f3faff;}.upload .upload-file {cursor: pointer;height: 100%;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);position: absolute;width: 100%;}.upload > .remove::after {align-items: center;background-color: #555659;border-radius: 50%;color: #fff;content: "✕";display: flex;font-size: 12px;height: 18px;justify-content: center;line-height: 12px;position: absolute;right: 12px;top: 12px;width: 18px;}.upload > .remove:hover::after {background-color: #707173;}.upload > .remove:active::after {background-color: #3b3d3f;}.upload-dragging {background-color: #f3faff;}.upload-no-border {border: 0;}.upload-dropping {background-color: #f3faff;border: 2px #0c92f3;border-style: dashed;}.upload-error {border: 2px #d94141;border-style: dashed;}.upload-preview {display: inline-block;line-height: 0;padding: 0;}.upload-icon {color: #d7d7d9;}.upload-icon.icon {margin-left: 0;margin-right: 0;}.animation-rotate-infinite {-webkit-animation: rotate-infinite infinite;-moz-animation: rotate-infinite infinite;-o-animation: rotate-infinite infinite;-ms-animation: rotate-infinite infinite;animation: rotate-infinite infinite;}.animation-fade-in {-webkit-animation: fade-in 1 ease both;-moz-animation: fade-in 1 ease both;-o-animation: fade-in 1 ease both;-ms-animation: fade-in 1 ease both;animation: fade-in 1 ease both;}.animation-fade-out {-webkit-animation: fade-out 1 ease both;-moz-animation: fade-out 1 ease both;-o-animation: fade-out 1 ease both;-ms-animation: fade-out 1 ease both;animation: fade-out 1 ease both;}.animation-ease {-webkit-animation-timing-function: ease;-moz-animation-timing-function: ease;-o-animation-timing-function: ease;-ms-animation-timing-function: ease;animation-timing-function: ease;}.animation-linear {-webkit-animation-timing-function: linear;-moz-animation-timing-function: linear;-o-animation-timing-function: linear;-ms-animation-timing-function: linear;animation-timing-function: linear;}.animation-duration-100ms {-webkit-animation-duration: 100ms;-moz-animation-duration: 100ms;-o-animation-duration: 100ms;-ms-animation-duration: 100ms;animation-duration: 100ms;}.animation-duration-200ms {-webkit-animation-duration: 200ms;-moz-animation-duration: 200ms;-o-animation-duration: 200ms;-ms-animation-duration: 200ms;animation-duration: 200ms;}.animation-duration-300ms {-webkit-animation-duration: 300ms;-moz-animation-duration: 300ms;-o-animation-duration: 300ms;-ms-animation-duration: 300ms;animation-duration: 300ms;}.animation-duration-400ms {-webkit-animation-duration: 400ms;-moz-animation-duration: 400ms;-o-animation-duration: 400ms;-ms-animation-duration: 400ms;animation-duration: 400ms;}.animation-duration-500ms {-webkit-animation-duration: 500ms;-moz-animation-duration: 500ms;-o-animation-duration: 500ms;-ms-animation-duration: 500ms;animation-duration: 500ms;}.animation-duration-1000ms {-webkit-animation-duration: 1000ms;-moz-animation-duration: 1000ms;-o-animation-duration: 1000ms;-ms-animation-duration: 1000ms;animation-duration: 1000ms;}.animation-duration-2000ms {-webkit-animation-duration: 2000ms;-moz-animation-duration: 2000ms;-o-animation-duration: 2000ms;-ms-animation-duration: 2000ms;animation-duration: 2000ms;}.animation-count-1 {-webkit-animation-iteration-count: 1;-moz-animation-iteration-count: 1;-o-animation-iteration-count: 1;-ms-animation-iteration-count: 1;animation-iteration-count: 1;}.animation-count-infinite {-webkit-animation-iteration-count: infinite;-moz-animation-iteration-count: infinite;-o-animation-iteration-count: infinite;-ms-animation-iteration-count: infinite;animation-iteration-count: infinite;}.animation-direction-normal {-webkit-animation-direction: normal;-moz-animation-direction: normal;-o-animation-direction: normal;-ms-animation-direction: normal;animation-direction: normal;}.animation-direction-reverse {-webkit-animation-direction: reverse;-moz-animation-direction: reverse;-o-animation-direction: reverse;-ms-animation-direction: reverse;animation-direction: reverse;}@-moz-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes rotate-infinite {0% {-webkit-transform: rotate(0);-moz-transform: rotate(0);-o-transform: rotate(0);-ms-transform: rotate(0);transform: rotate(0);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-moz-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fade-in {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fade-out {0% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}.border {border: 1px solid #e3e4e6;}.border-top {border-top: 1px solid #e3e4e6;}.border-right {border-right: 1px solid #e3e4e6;}.border-bottom {border-bottom: 1px solid #e3e4e6;}.border-left {border-left: 1px solid #e3e4e6;}.border-width-1 {border-width: 4px;}.border-width-2 {border-width: 8px;}.border-width-3 {border-width: 12px;}.border-width-4 {border-width: 16px;}.border-width-5 {border-width: 20px;}.border-width-6 {border-width: 24px;}.border-width-7 {border-width: 28px;}.border-width-8 {border-width: 32px;}.border-width-9 {border-width: 36px;}.border-width-10 {border-width: 40px;}.border-width-11 {border-width: 44px;}.border-width-12 {border-width: 48px;}.border-width-13 {border-width: 52px;}.border-width-14 {border-width: 56px;}.border-width-15 {border-width: 60px;}.border-width-16 {border-width: 64px;}.border-width-17 {border-width: 68px;}.border-width-18 {border-width: 72px;}.border-width-19 {border-width: 76px;}.border-width-20 {border-width: 80px;}.border-width-21 {border-width: 84px;}.border-width-22 {border-width: 88px;}.border-width-23 {border-width: 92px;}.border-width-24 {border-width: 96px;}.border-width-25 {border-width: 100px;}.border-width-26 {border-width: 104px;}.border-width-27 {border-width: 108px;}.border-width-28 {border-width: 112px;}.border-width-29 {border-width: 116px;}.border-width-30 {border-width: 120px;}.border-none {border: 0;}.border-top-none {border-top: 0;}.border-right-none {border-right: 0;}.border-bottom-none {border-bottom: 0;}.border-left-none {border-left: 0;}.rounded {border-radius: 3px;}.circle {border-radius: 50%;}.rounded-top {border-radius: 3px 3px 0 0;}.rounded-right {border-radius: 0 3px 3px 0;}.rounded-bottom {border-radius: 0 0 3px 3px;}.rounded-left {border-radius: 3px 0 0 3px;}.not-rounded {border-radius: 0;}.dashed {border-style: dashed;}.text-white {color: #fff;}.bg-white {background-color: #fff;}.border-white {border-color: #fff;}.text-black {color: #000;}.bg-black {background-color: #000;}.border-black {border-color: #000;}.text-ghost {color: #f4f7fa;}.bg-ghost {background-color: #f4f7fa;}.border-ghost {border-color: #f4f7fa;}.text-gray {color: #969799;}.bg-gray {background-color: #969799;}.border-gray {border-color: #969799;}.text-blue {color: #0c92f3;}.bg-blue {background-color: #0c92f3;}.border-blue {border-color: #0c92f3;}.text-red {color: #d94141;}.bg-red {background-color: #d94141;}.border-red {border-color: #d94141;}.text-green {color: #39bf71;}.bg-green {background-color: #39bf71;}.border-green {border-color: #39bf71;}.text-yellow {color: #ffa60d;}.bg-yellow {background-color: #ffa60d;}.border-yellow {border-color: #ffa60d;}.text-rose {color: #dc4c7d;}.bg-rose {background-color: #dc4c7d;}.border-rose {border-color: #dc4c7d;}.text-violet {color: #a452cc;}.bg-violet {background-color: #a452cc;}.border-violet {border-color: #a452cc;}.text-turquoise {color: #1cadba;}.bg-turquoise {background-color: #1cadba;}.border-turquoise {border-color: #1cadba;}.text-gray-50 {color: #f9f9f9;}.bg-gray-50 {background-color: #f9f9f9;}.border-gray-50 {border-color: #f9f9f9;}.text-gray-100 {color: #f0f1f2;}.bg-gray-100 {background-color: #f0f1f2;}.border-gray-100 {border-color: #f0f1f2;}.text-gray-200 {color: #e3e4e6;}.bg-gray-200 {background-color: #e3e4e6;}.border-gray-200 {border-color: #e3e4e6;}.text-gray-300 {color: #d7d7d9;}.bg-gray-300 {background-color: #d7d7d9;}.border-gray-300 {border-color: #d7d7d9;}.text-gray-400 {color: #b1b1b3;}.bg-gray-400 {background-color: #b1b1b3;}.border-gray-400 {border-color: #b1b1b3;}.text-gray-500 {color: #969799;}.bg-gray-500 {background-color: #969799;}.border-gray-500 {border-color: #969799;}.text-gray-600 {color: #707173;}.bg-gray-600 {background-color: #707173;}.border-gray-600 {border-color: #707173;}.text-gray-700 {color: #555659;}.bg-gray-700 {background-color: #555659;}.border-gray-700 {border-color: #555659;}.text-gray-800 {color: #3b3d3f;}.bg-gray-800 {background-color: #3b3d3f;}.border-gray-800 {border-color: #3b3d3f;}.text-gray-900 {color: #222326;}.bg-gray-900 {background-color: #222326;}.border-gray-900 {border-color: #222326;}.text-blue-50 {color: #f3faff;}.bg-blue-50 {background-color: #f3faff;}.border-blue-50 {border-color: #f3faff;}.text-red-50 {color: #fff7f7;}.bg-red-50 {background-color: #fff7f7;}.border-red-50 {border-color: #fff7f7;}.text-green-50 {color: #e1fae5;}.bg-green-50 {background-color: #e1fae5;}.border-green-50 {border-color: #e1fae5;}.text-yellow-50 {color: #fff6e5;}.bg-yellow-50 {background-color: #fff6e5;}.border-yellow-50 {border-color: #fff6e5;}.text-blue-100 {color: #e1f3ff;}.bg-blue-100 {background-color: #e1f3ff;}.border-blue-100 {border-color: #e1f3ff;}.text-red-100 {color: #ffe6e6;}.bg-red-100 {background-color: #ffe6e6;}.border-red-100 {border-color: #ffe6e6;}.text-green-100 {color: #d4f5c4;}.bg-green-100 {background-color: #d4f5c4;}.border-green-100 {border-color: #d4f5c4;}.text-yellow-100 {color: #fec;}.bg-yellow-100 {background-color: #fec;}.border-yellow-100 {border-color: #fec;}.text-blue-200 {color: #bfe5ff;}.bg-blue-200 {background-color: #bfe5ff;}.border-blue-200 {border-color: #bfe5ff;}.text-red-200 {color: #ffbfbf;}.bg-red-200 {background-color: #ffbfbf;}.border-red-200 {border-color: #ffbfbf;}.text-green-200 {color: #b4f0a8;}.bg-green-200 {background-color: #b4f0a8;}.border-green-200 {border-color: #b4f0a8;}.text-yellow-200 {color: #ffe5b2;}.bg-yellow-200 {background-color: #ffe5b2;}.border-yellow-200 {border-color: #ffe5b2;}.text-blue-300 {color: #a6daff;}.bg-blue-300 {background-color: #a6daff;}.border-blue-300 {border-color: #a6daff;}.text-red-300 {color: #f99;}.bg-red-300 {background-color: #f99;}.border-red-300 {border-color: #f99;}.text-green-300 {color: #8ae58a;}.bg-green-300 {background-color: #8ae58a;}.border-green-300 {border-color: #8ae58a;}.text-yellow-300 {color: #ffdf88;}.bg-yellow-300 {background-color: #ffdf88;}.border-yellow-300 {border-color: #ffdf88;}.text-blue-400 {color: #4cb5ff;}.bg-blue-400 {background-color: #4cb5ff;}.border-blue-400 {border-color: #4cb5ff;}.text-red-400 {color: #f26161;}.bg-red-400 {background-color: #f26161;}.border-red-400 {border-color: #f26161;}.text-green-400 {color: #61d086;}.bg-green-400 {background-color: #61d086;}.border-green-400 {border-color: #61d086;}.text-yellow-400 {color: #fb3;}.bg-yellow-400 {background-color: #fb3;}.border-yellow-400 {border-color: #fb3;}.text-blue-500 {color: #0c92f3;}.bg-blue-500 {background-color: #0c92f3;}.border-blue-500 {border-color: #0c92f3;}.text-red-500 {color: #d94141;}.bg-red-500 {background-color: #d94141;}.border-red-500 {border-color: #d94141;}.text-green-500 {color: #39bf71;}.bg-green-500 {background-color: #39bf71;}.border-green-500 {border-color: #39bf71;}.text-yellow-500 {color: #ffa60d;}.bg-yellow-500 {background-color: #ffa60d;}.border-yellow-500 {border-color: #ffa60d;}.text-blue-600 {color: #007fd9;}.bg-blue-600 {background-color: #007fd9;}.border-blue-600 {border-color: #007fd9;}.text-red-600 {color: #bf3939;}.bg-red-600 {background-color: #bf3939;}.border-red-600 {border-color: #bf3939;}.text-green-600 {color: #19a654;}.bg-green-600 {background-color: #19a654;}.border-green-600 {border-color: #19a654;}.text-yellow-600 {color: #ff9000;}.bg-yellow-600 {background-color: #ff9000;}.border-yellow-600 {border-color: #ff9000;}.text-blue-700 {color: #0068b3;}.bg-blue-700 {background-color: #0068b3;}.border-blue-700 {border-color: #0068b3;}.text-red-700 {color: #a62929;}.bg-red-700 {background-color: #a62929;}.border-red-700 {border-color: #a62929;}.text-green-700 {color: #0e8c42;}.bg-green-700 {background-color: #0e8c42;}.border-green-700 {border-color: #0e8c42;}.text-yellow-700 {color: #e67600;}.bg-yellow-700 {background-color: #e67600;}.border-yellow-700 {border-color: #e67600;}.text-turquoise-50 {color: #f0fbfc;}.bg-turquoise-50 {background-color: #f0fbfc;}.border-turquoise-50 {border-color: #f0fbfc;}.text-turquoise-100 {color: #d9f7fa;}.bg-turquoise-100 {background-color: #d9f7fa;}.border-turquoise-100 {border-color: #d9f7fa;}.text-turquoise-200 {color: #b8f0f5;}.bg-turquoise-200 {background-color: #b8f0f5;}.border-turquoise-200 {border-color: #b8f0f5;}.text-turquoise-300 {color: #91eaf2;}.bg-turquoise-300 {background-color: #91eaf2;}.border-turquoise-300 {border-color: #91eaf2;}.text-turquoise-400 {color: #33c0cd;}.bg-turquoise-400 {background-color: #33c0cd;}.border-turquoise-400 {border-color: #33c0cd;}.text-turquoise-500 {color: #1cadba;}.bg-turquoise-500 {background-color: #1cadba;}.border-turquoise-500 {border-color: #1cadba;}.text-turquoise-600 {color: #0097a6;}.bg-turquoise-600 {background-color: #0097a6;}.border-turquoise-600 {border-color: #0097a6;}.text-turquoise-700 {color: #007580;}.bg-turquoise-700 {background-color: #007580;}.border-turquoise-700 {border-color: #007580;}.text-turquoise-800 {color: #005e66;}.bg-turquoise-800 {background-color: #005e66;}.border-turquoise-800 {border-color: #005e66;}.text-turquoise-900 {color: #00464d;}.bg-turquoise-900 {background-color: #00464d;}.border-turquoise-900 {border-color: #00464d;}.text-violet-50 {color: #f8ebff;}.bg-violet-50 {background-color: #f8ebff;}.border-violet-50 {border-color: #f8ebff;}.text-violet-100 {color: #f5e0ff;}.bg-violet-100 {background-color: #f5e0ff;}.border-violet-100 {border-color: #f5e0ff;}.text-violet-200 {color: #ebc4ff;}.bg-violet-200 {background-color: #ebc4ff;}.border-violet-200 {border-color: #ebc4ff;}.text-violet-300 {color: #dea2fc;}.bg-violet-300 {background-color: #dea2fc;}.border-violet-300 {border-color: #dea2fc;}.text-violet-400 {color: #bf75e3;}.bg-violet-400 {background-color: #bf75e3;}.border-violet-400 {border-color: #bf75e3;}.text-violet-500 {color: #a452cc;}.bg-violet-500 {background-color: #a452cc;}.border-violet-500 {border-color: #a452cc;}.text-violet-600 {color: #9c2bd4;}.bg-violet-600 {background-color: #9c2bd4;}.border-violet-600 {border-color: #9c2bd4;}.text-violet-700 {color: #801bb2;}.bg-violet-700 {background-color: #801bb2;}.border-violet-700 {border-color: #801bb2;}.text-violet-800 {color: #620e8c;}.bg-violet-800 {background-color: #620e8c;}.border-violet-800 {border-color: #620e8c;}.text-violet-900 {color: #521173;}.bg-violet-900 {background-color: #521173;}.border-violet-900 {border-color: #521173;}.bg-transparent {background: transparent;}.cursor-pointer {cursor: pointer;}.cursor-text {cursor: text;}.cursor-default {cursor: default;}.cursor-inherit {cursor: inherit;}.flex {display: flex;}.flex-column {flex-direction: column;}.flex-row {flex-direction: row;}.flex-row-reverse {flex-direction: row-reverse;}.flex-column-reverse {flex-direction: column-reverse;}.flex-wrap {flex-wrap: wrap;}.flex-nowrap {flex-wrap: nowrap;}.flex-grow {flex: 1 0 auto;}.flex-shrink {flex: 0 1 auto;}.flex-auto {flex: 1 1 auto;min-height: 0;min-width: 0;}.flex-none {flex: none;}.items-start {align-items: flex-start;}.items-end {align-items: flex-end;}.items-center {align-items: center;}.items-baseline {align-items: baseline;}.items-stretch {align-items: stretch;}.self-start {align-self: flex-start;}.self-end {align-self: flex-end;}.self-center {align-self: center;}.self-baseline {align-self: baseline;}.self-stretch {align-self: stretch;}.justify-start {justify-content: flex-start;}.justify-end {justify-content: flex-end;}.justify-center {justify-content: center;}.justify-between {justify-content: space-between;}.justify-around {justify-content: space-around;}.justify-evenly {justify-content: space-evenly;}.content-start {align-content: flex-start;}.content-end {align-content: flex-end;}.content-center {align-content: center;}.content-between {align-content: space-between;}.content-around {align-content: space-around;}.content-stretch {align-content: stretch;}.order-0 {order: 0;}.order-1 {order: 1;}.order-2 {order: 2;}.order-3 {order: 3;}.order-last {order: 99999;}.icon-size-base {height: 16px;width: 16px;}.icon-size-caption,.momentum-body .icon-size-caption {height: 12px;width: 12px;}.identicon-size,.momentum-body .identicon-size {height: 24px;width: 24px;line-height: 24px;}.display-none {display: none;}.display-inline,.inline {display: inline;}.display-block,.block {display: block;}.display-inline-block,.inline-block {display: inline-block;}.display-table,.table {display: table;}.display-table-cell,.table-cell {display: table-cell;}.visibility-hidden {visibility: hidden;}.overflow-hidden {overflow: hidden;}.overflow-scroll {overflow: scroll;}.overflow-auto {overflow: auto;}.overflow-visible {overflow: visible;}.float-left {float: left;}.float-right {float: right;}.fit-width {max-width: 100%;}.bulleted-list {margin-left: 16px;list-style-type: circle;}.bulleted-list li {margin-bottom: 8px;}.m0 {margin: 0;}.mt0 {margin-top: 0;}.mr0 {margin-right: 0;}.mb0 {margin-bottom: 0;}.ml0 {margin-left: 0;}.mx0 {margin-left: 0;margin-right: 0;}.my0 {margin-bottom: 0;margin-top: 0;}.m0_5 {margin: 4px;}.mt0_5 {margin-top: 4px;}.mr0_5 {margin-right: 4px;}.mb0_5 {margin-bottom: 4px;}.ml0_5 {margin-left: 4px;}.mx0_5 {margin-left: 4px;margin-right: 4px;}.my0_5 {margin-bottom: 4px;margin-top: 4px;}.m1 {margin: 8px;}.mt1 {margin-top: 8px;}.mr1 {margin-right: 8px;}.mb1 {margin-bottom: 8px;}.ml1 {margin-left: 8px;}.mx1 {margin-left: 8px;margin-right: 8px;}.my1 {margin-bottom: 8px;margin-top: 8px;}.m1_5 {margin: 12px;}.mt1_5 {margin-top: 12px;}.mr1_5 {margin-right: 12px;}.mb1_5 {margin-bottom: 12px;}.ml1_5 {margin-left: 12px;}.mx1_5 {margin-left: 12px;margin-right: 12px;}.my1_5 {margin-bottom: 12px;margin-top: 12px;}.m2 {margin: 16px;}.mt2 {margin-top: 16px;}.mr2 {margin-right: 16px;}.mb2 {margin-bottom: 16px;}.ml2 {margin-left: 16px;}.mx2 {margin-left: 16px;margin-right: 16px;}.my2 {margin-bottom: 16px;margin-top: 16px;}.m3 {margin: 24px;}.mt3 {margin-top: 24px;}.mr3 {margin-right: 24px;}.mb3 {margin-bottom: 24px;}.ml3 {margin-left: 24px;}.mx3 {margin-left: 24px;margin-right: 24px;}.my3 {margin-bottom: 24px;margin-top: 24px;}.m4 {margin: 32px;}.mt4 {margin-top: 32px;}.mr4 {margin-right: 32px;}.mb4 {margin-bottom: 32px;}.ml4 {margin-left: 32px;}.mx4 {margin-left: 32px;margin-right: 32px;}.my4 {margin-bottom: 32px;margin-top: 32px;}.m5 {margin: 40px;}.mt5 {margin-top: 40px;}.mr5 {margin-right: 40px;}.mb5 {margin-bottom: 40px;}.ml5 {margin-left: 40px;}.mx5 {margin-left: 40px;margin-right: 40px;}.my5 {margin-bottom: 40px;margin-top: 40px;}.m10 {margin: 80px;}.mt10 {margin-top: 80px;}.mr10 {margin-right: 80px;}.mb10 {margin-bottom: 80px;}.ml10 {margin-left: 80px;}.mx10 {margin-left: 80px;margin-right: 80px;}.my10 {margin-bottom: 80px;margin-top: 80px;}.mn1 {margin: -8px;}.mtn1 {margin-top: -8px;}.mrn1 {margin-right: -8px;}.mbn1 {margin-bottom: -8px;}.mln1 {margin-left: -8px;}.mxn1 {margin-left: -8px;margin-right: -8px;}.myn1 {margin-bottom: -8px;margin-top: -8px;}.mxn2 {margin-left: -16px;margin-right: -16px;}.mxn3 {margin-left: -24px;margin-right: -24px;}.mxn4 {margin-left: -32px;margin-right: -32px;}.mt-auto {margin-top: auto;}.mb-auto {margin-bottom: auto;}.my-auto {margin-top: auto;margin-bottom: auto;}.ml-auto {margin-left: auto;}.mr-auto {margin-right: auto;}.mx-auto {margin-left: auto;margin-right: auto;}.opacity-0 {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}.opacity-0_1 {opacity: 0.1;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=10)";filter: alpha(opacity=10);}.opacity-0_2 {opacity: 0.2;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=20)";filter: alpha(opacity=20);}.opacity-0_3 {opacity: 0.3;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=30)";filter: alpha(opacity=30);}.opacity-0_4 {opacity: 0.4;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=40)";filter: alpha(opacity=40);}.opacity-0_5 {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.opacity-0_6 {opacity: 0.6;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=60)";filter: alpha(opacity=60);}.opacity-0_7 {opacity: 0.7;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=70)";filter: alpha(opacity=70);}.opacity-0_8 {opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.opacity-0_9 {opacity: 0.9;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=90)";filter: alpha(opacity=90);}.opacity-1 {opacity: 1;-ms-filter: none;filter: none;}.outline-none {outline: 0;}.p0 {padding: 0;}.pt0 {padding-top: 0;}.pr0 {padding-right: 0;}.pb0 {padding-bottom: 0;}.pl0 {padding-left: 0;}.px0 {padding-left: 0;padding-right: 0;}.py0 {padding-bottom: 0;padding-top: 0;}.p0_5 {padding: 4px;}.pt0_5 {padding-top: 4px;}.pr0_5 {padding-right: 4px;}.pb0_5 {padding-bottom: 4px;}.pl0_5 {padding-left: 4px;}.px0_5 {padding-left: 4px;padding-right: 4px;}.py0_5 {padding-bottom: 4px;padding-top: 4px;}.p1 {padding: 8px;}.pt1 {padding-top: 8px;}.pr1 {padding-right: 8px;}.pb1 {padding-bottom: 8px;}.pl1 {padding-left: 8px;}.py1 {padding-bottom: 8px;padding-top: 8px;}.px1 {padding-left: 8px;padding-right: 8px;}.p1_5 {padding: 12px;}.pt1_5 {padding-top: 12px;}.pr1_5 {padding-right: 12px;}.pb1_5 {padding-bottom: 12px;}.pl1_5 {padding-left: 12px;}.px1_5 {padding-left: 12px;padding-right: 12px;}.py1_5 {padding-bottom: 12px;padding-top: 12px;}.p2 {padding: 16px;}.pt2 {padding-top: 16px;}.pr2 {padding-right: 16px;}.pb2 {padding-bottom: 16px;}.pl2 {padding-left: 16px;}.py2 {padding-bottom: 16px;padding-top: 16px;}.px2 {padding-left: 16px;padding-right: 16px;}.p3 {padding: 24px;}.pt3 {padding-top: 24px;}.pr3 {padding-right: 24px;}.pb3 {padding-bottom: 24px;}.pl3 {padding-left: 24px;}.py3 {padding-bottom: 24px;padding-top: 24px;}.px3 {padding-left: 24px;padding-right: 24px;}.p4 {padding: 32px;}.pt4 {padding-top: 32px;}.pr4 {padding-right: 32px;}.pb4 {padding-bottom: 32px;}.pl4 {padding-left: 32px;}.py4 {padding-bottom: 32px;padding-top: 32px;}.px4 {padding-left: 32px;padding-right: 32px;}.p5 {padding: 40px;}.pt5 {padding-top: 40px;}.pr5 {padding-right: 40px;}.pb5 {padding-bottom: 40px;}.pl5 {padding-left: 40px;}.py5 {padding-bottom: 40px;padding-top: 40px;}.px5 {padding-left: 40px;padding-right: 40px;}.p10 {padding: 80px;}.pt10 {padding-top: 80px;}.pr10 {padding-right: 80px;}.pb10 {padding-bottom: 80px;}.pl10 {padding-left: 80px;}.py10 {padding-bottom: 80px;padding-top: 80px;}.px10 {padding-left: 80px;padding-right: 80px;}.pointer-events-none {pointer-events: none;}.relative {position: relative;}.absolute {position: absolute;}.sticky {position: sticky;}.top-0 {top: 0;}.right-0 {right: 0;}.bottom-0 {bottom: 0;}.left-0 {left: 0;}.height-full {height: 100%;}.width-full {width: 100%;}.max-width-full {max-width: 100%;}.width-0 {width: 0;}.height-0 {height: 0;}.width-auto {width: auto;}.min-width-1 {min-width: 8px;}.min-height-1 {min-height: 8px;}.max-width-1 {max-width: 8px;}.max-height-1 {max-height: 8px;}.min-width-2 {min-width: 16px;}.min-height-2 {min-height: 16px;}.max-width-2 {max-width: 16px;}.max-height-2 {max-height: 16px;}.min-width-3 {min-width: 24px;}.min-height-3 {min-height: 24px;}.max-width-3 {max-width: 24px;}.max-height-3 {max-height: 24px;}.min-width-4 {min-width: 32px;}.min-height-4 {min-height: 32px;}.max-width-4 {max-width: 32px;}.max-height-4 {max-height: 32px;}.min-width-5 {min-width: 40px;}.min-height-5 {min-height: 40px;}.max-width-5 {max-width: 40px;}.max-height-5 {max-height: 40px;}.min-width-6 {min-width: 48px;}.min-height-6 {min-height: 48px;}.max-width-6 {max-width: 48px;}.max-height-6 {max-height: 48px;}.min-width-7 {min-width: 56px;}.min-height-7 {min-height: 56px;}.max-width-7 {max-width: 56px;}.max-height-7 {max-height: 56px;}.min-width-8 {min-width: 64px;}.min-height-8 {min-height: 64px;}.max-width-8 {max-width: 64px;}.max-height-8 {max-height: 64px;}.min-width-9 {min-width: 72px;}.min-height-9 {min-height: 72px;}.max-width-9 {max-width: 72px;}.max-height-9 {max-height: 72px;}.min-width-10 {min-width: 80px;}.min-height-10 {min-height: 80px;}.max-width-10 {max-width: 80px;}.max-height-10 {max-height: 80px;}.min-width-11 {min-width: 88px;}.min-height-11 {min-height: 88px;}.max-width-11 {max-width: 88px;}.max-height-11 {max-height: 88px;}.min-width-12 {min-width: 96px;}.min-height-12 {min-height: 96px;}.max-width-12 {max-width: 96px;}.max-height-12 {max-height: 96px;}.min-width-13 {min-width: 104px;}.min-height-13 {min-height: 104px;}.max-width-13 {max-width: 104px;}.max-height-13 {max-height: 104px;}.min-width-14 {min-width: 112px;}.min-height-14 {min-height: 112px;}.max-width-14 {max-width: 112px;}.max-height-14 {max-height: 112px;}.min-width-15 {min-width: 120px;}.min-height-15 {min-height: 120px;}.max-width-15 {max-width: 120px;}.max-height-15 {max-height: 120px;}.min-width-16 {min-width: 128px;}.min-height-16 {min-height: 128px;}.max-width-16 {max-width: 128px;}.max-height-16 {max-height: 128px;}.min-width-17 {min-width: 136px;}.min-height-17 {min-height: 136px;}.max-width-17 {max-width: 136px;}.max-height-17 {max-height: 136px;}.min-width-18 {min-width: 144px;}.min-height-18 {min-height: 144px;}.max-width-18 {max-width: 144px;}.max-height-18 {max-height: 144px;}.min-width-19 {min-width: 152px;}.min-height-19 {min-height: 152px;}.max-width-19 {max-width: 152px;}.max-height-19 {max-height: 152px;}.min-width-20 {min-width: 160px;}.min-height-20 {min-height: 160px;}.max-width-20 {max-width: 160px;}.max-height-20 {max-height: 160px;}.min-width-21 {min-width: 168px;}.min-height-21 {min-height: 168px;}.max-width-21 {max-width: 168px;}.max-height-21 {max-height: 168px;}.min-width-22 {min-width: 176px;}.min-height-22 {min-height: 176px;}.max-width-22 {max-width: 176px;}.max-height-22 {max-height: 176px;}.min-width-23 {min-width: 184px;}.min-height-23 {min-height: 184px;}.max-width-23 {max-width: 184px;}.max-height-23 {max-height: 184px;}.min-width-24 {min-width: 192px;}.min-height-24 {min-height: 192px;}.max-width-24 {max-width: 192px;}.max-height-24 {max-height: 192px;}.min-width-25 {min-width: 200px;}.min-height-25 {min-height: 200px;}.max-width-25 {max-width: 200px;}.max-height-25 {max-height: 200px;}.min-width-26 {min-width: 208px;}.min-height-26 {min-height: 208px;}.max-width-26 {max-width: 208px;}.max-height-26 {max-height: 208px;}.min-width-27 {min-width: 216px;}.min-height-27 {min-height: 216px;}.max-width-27 {max-width: 216px;}.max-height-27 {max-height: 216px;}.min-width-28 {min-width: 224px;}.min-height-28 {min-height: 224px;}.max-width-28 {max-width: 224px;}.max-height-28 {max-height: 224px;}.min-width-29 {min-width: 232px;}.min-height-29 {min-height: 232px;}.max-width-29 {max-width: 232px;}.max-height-29 {max-height: 232px;}.min-width-30 {min-width: 240px;}.min-height-30 {min-height: 240px;}.max-width-30 {max-width: 240px;}.max-height-30 {max-height: 240px;}.min-width-40 {min-width: 320px;}.min-height-40 {min-height: 320px;}.max-width-40 {max-width: 320px;}.max-height-40 {max-height: 320px;}.min-width-50 {min-width: 400px;}.min-height-50 {min-height: 400px;}.max-width-50 {max-width: 400px;}.max-height-50 {max-height: 400px;}.min-width-60 {min-width: 480px;}.min-height-60 {min-height: 480px;}.max-width-60 {max-width: 480px;}.max-height-60 {max-height: 480px;}.min-width-70 {min-width: 560px;}.min-height-70 {min-height: 560px;}.max-width-70 {max-width: 560px;}.max-height-70 {max-height: 560px;}.min-width-80 {min-width: 640px;}.min-height-80 {min-height: 640px;}.max-width-80 {max-width: 640px;}.max-height-80 {max-height: 640px;}.min-width-90 {min-width: 720px;}.min-height-90 {min-height: 720px;}.max-width-90 {max-width: 720px;}.max-height-90 {max-height: 720px;}.min-width-100 {min-width: 800px;}.min-height-100 {min-height: 800px;}.max-width-100 {max-width: 800px;}.max-height-100 {max-height: 800px;}.min-width-110 {min-width: 880px;}.min-height-110 {min-height: 880px;}.max-width-110 {max-width: 880px;}.max-height-110 {max-height: 880px;}.min-width-120 {min-width: 960px;}.min-height-120 {min-height: 960px;}.max-width-120 {max-width: 960px;}.max-height-120 {max-height: 960px;}.min-width-36 {min-width: 288px;}.max-height-51 {max-height: 408px;}.max-height-inherit {max-height: inherit;}.valign-baseline {vertical-align: baseline;}.valign-text-top {vertical-align: text-top;}.valign-top {vertical-align: top;}.valign-middle {vertical-align: middle;}.valign-bottom {vertical-align: bottom;}.font-family-inherit {font-family: inherit;}.font-size-inherit {font-size: inherit;}.text-decoration-none {text-decoration: none;}.bold {font-weight: bold;}.regular {font-weight: normal;}.italic {font-style: italic;}.strikethrough {text-decoration: line-through;}.underline {text-decoration: underline;}.caps {text-transform: uppercase;letter-spacing: 1px;}.lowercase {text-transform: lowercase;}.capitalize {text-transform: capitalize;}.align-left {text-align: left;}.align-center {text-align: center;}.align-right {text-align: right;}.align-justify {text-align: justify;}.nowrap {white-space: nowrap;}.break-word {word-wrap: break-word;}.line-height-1 {line-height: 24px;}.line-height-2 {line-height: 48px;}.line-height-3 {line-height: 72px;}.line-height-4 {line-height: 96px;}.list-style-none {list-style: none;}.ellipsis {overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;white-space: nowrap;}.list-reset {list-style: none;padding-left: 0;}.text-overflow-initial {-o-text-overflow: initial;text-overflow: initial;}.transition-property-all {-webkit-transition-property: all;-moz-transition-property: all;-o-transition-property: all;-ms-transition-property: all;transition-property: all;}.transition-property-opacity {-webkit-transition-property: opacity;-moz-transition-property: opacity;-o-transition-property: opacity;-ms-transition-property: opacity;transition-property: opacity;}.transition-duration-sec1 {-webkit-transition-duration: 1s;-moz-transition-duration: 1s;-o-transition-duration: 1s;-ms-transition-duration: 1s;transition-duration: 1s;}.transition-duration-sec1_5 {-webkit-transition-duration: 1.5s;-moz-transition-duration: 1.5s;-o-transition-duration: 1.5s;-ms-transition-duration: 1.5s;transition-duration: 1.5s;}.transition-duration-sec2 {-webkit-transition-duration: 2s;-moz-transition-duration: 2s;-o-transition-duration: 2s;-ms-transition-duration: 2s;transition-duration: 2s;}.transition-duration-sec2_5 {-webkit-transition-duration: 2.5s;-moz-transition-duration: 2.5s;-o-transition-duration: 2.5s;-ms-transition-duration: 2.5s;transition-duration: 2.5s;}.transition-duration-sec3 {-webkit-transition-duration: 3s;-moz-transition-duration: 3s;-o-transition-duration: 3s;-ms-transition-duration: 3s;transition-duration: 3s;}.transition-duration-sec3_5 {-webkit-transition-duration: 3.5s;-moz-transition-duration: 3.5s;-o-transition-duration: 3.5s;-ms-transition-duration: 3.5s;transition-duration: 3.5s;}.transition-duration-sec4 {-webkit-transition-duration: 4s;-moz-transition-duration: 4s;-o-transition-duration: 4s;-ms-transition-duration: 4s;transition-duration: 4s;}.transition-duration-sec4_5 {-webkit-transition-duration: 4.5s;-moz-transition-duration: 4.5s;-o-transition-duration: 4.5s;-ms-transition-duration: 4.5s;transition-duration: 4.5s;}.transition-duration-sec5 {-webkit-transition-duration: 5s;-moz-transition-duration: 5s;-o-transition-duration: 5s;-ms-transition-duration: 5s;transition-duration: 5s;}.transition-duration-sec6 {-webkit-transition-duration: 6s;-moz-transition-duration: 6s;-o-transition-duration: 6s;-ms-transition-duration: 6s;transition-duration: 6s;}.transition-duration-sec7 {-webkit-transition-duration: 7s;-moz-transition-duration: 7s;-o-transition-duration: 7s;-ms-transition-duration: 7s;transition-duration: 7s;}.transition-duration-sec8 {-webkit-transition-duration: 8s;-moz-transition-duration: 8s;-o-transition-duration: 8s;-ms-transition-duration: 8s;transition-duration: 8s;}.transition-duration-sec9 {-webkit-transition-duration: 9s;-moz-transition-duration: 9s;-o-transition-duration: 9s;-ms-transition-duration: 9s;transition-duration: 9s;}.transition-duration-sec10 {-webkit-transition-duration: 10s;-moz-transition-duration: 10s;-o-transition-duration: 10s;-ms-transition-duration: 10s;transition-duration: 10s;}.transition-duration-ms100 {-webkit-transition-duration: 100ms;-moz-transition-duration: 100ms;-o-transition-duration: 100ms;-ms-transition-duration: 100ms;transition-duration: 100ms;}.transition-duration-ms200 {-webkit-transition-duration: 200ms;-moz-transition-duration: 200ms;-o-transition-duration: 200ms;-ms-transition-duration: 200ms;transition-duration: 200ms;}.transition-duration-ms300 {-webkit-transition-duration: 300ms;-moz-transition-duration: 300ms;-o-transition-duration: 300ms;-ms-transition-duration: 300ms;transition-duration: 300ms;}.transition-duration-ms400 {-webkit-transition-duration: 400ms;-moz-transition-duration: 400ms;-o-transition-duration: 400ms;-ms-transition-duration: 400ms;transition-duration: 400ms;}.transition-duration-ms500 {-webkit-transition-duration: 500ms;-moz-transition-duration: 500ms;-o-transition-duration: 500ms;-ms-transition-duration: 500ms;transition-duration: 500ms;}.transition-duration-ms600 {-webkit-transition-duration: 600ms;-moz-transition-duration: 600ms;-o-transition-duration: 600ms;-ms-transition-duration: 600ms;transition-duration: 600ms;}.transition-duration-ms700 {-webkit-transition-duration: 700ms;-moz-transition-duration: 700ms;-o-transition-duration: 700ms;-ms-transition-duration: 700ms;transition-duration: 700ms;}.transition-duration-ms800 {-webkit-transition-duration: 800ms;-moz-transition-duration: 800ms;-o-transition-duration: 800ms;-ms-transition-duration: 800ms;transition-duration: 800ms;}.transition-duration-ms900 {-webkit-transition-duration: 900ms;-moz-transition-duration: 900ms;-o-transition-duration: 900ms;-ms-transition-duration: 900ms;transition-duration: 900ms;}.transition-tf-ease {-webkit-transition-timing-function: ease;-moz-transition-timing-function: ease;-o-transition-timing-function: ease;-ms-transition-timing-function: ease;transition-timing-function: ease;}.transition-tf-linear {-webkit-transition-timing-function: linear;-moz-transition-timing-function: linear;-o-transition-timing-function: linear;-ms-transition-timing-function: linear;transition-timing-function: linear;}.transition-tf-ease-in {-webkit-transition-timing-function: ease-in;-moz-transition-timing-function: ease-in;-o-transition-timing-function: ease-in;-ms-transition-timing-function: ease-in;transition-timing-function: ease-in;}.transition-tf-ease-out {-webkit-transition-timing-function: ease-out;-moz-transition-timing-function: ease-out;-o-transition-timing-function: ease-out;-ms-transition-timing-function: ease-out;transition-timing-function: ease-out;}.transition-tf-ease-in-out {-webkit-transition-timing-function: ease-in-out;-moz-transition-timing-function: ease-in-out;-o-transition-timing-function: ease-in-out;-ms-transition-timing-function: ease-in-out;transition-timing-function: ease-in-out;}.transition-tf-step-start {-webkit-transition-timing-function: step-start;-moz-transition-timing-function: step-start;-o-transition-timing-function: step-start;-ms-transition-timing-function: step-start;transition-timing-function: step-start;}.transition-tf-step-end {-webkit-transition-timing-function: step-end;-moz-transition-timing-function: step-end;-o-transition-timing-function: step-end;-ms-transition-timing-function: step-end;transition-timing-function: step-end;}.transition-delay-sec1 {-webkit-transition-delay: 1s;-moz-transition-delay: 1s;-o-transition-delay: 1s;-ms-transition-delay: 1s;transition-delay: 1s;}.transition-delay-sec1_5 {-webkit-transition-delay: 1.5s;-moz-transition-delay: 1.5s;-o-transition-delay: 1.5s;-ms-transition-delay: 1.5s;transition-delay: 1.5s;}.transition-delay-sec2 {-webkit-transition-delay: 2s;-moz-transition-delay: 2s;-o-transition-delay: 2s;-ms-transition-delay: 2s;transition-delay: 2s;}.transition-delay-sec2_5 {-webkit-transition-delay: 2.5s;-moz-transition-delay: 2.5s;-o-transition-delay: 2.5s;-ms-transition-delay: 2.5s;transition-delay: 2.5s;}.transition-delay-sec3 {-webkit-transition-delay: 3s;-moz-transition-delay: 3s;-o-transition-delay: 3s;-ms-transition-delay: 3s;transition-delay: 3s;}.transition-delay-sec3_5 {-webkit-transition-delay: 3.5s;-moz-transition-delay: 3.5s;-o-transition-delay: 3.5s;-ms-transition-delay: 3.5s;transition-delay: 3.5s;}.transition-delay-sec4 {-webkit-transition-delay: 4s;-moz-transition-delay: 4s;-o-transition-delay: 4s;-ms-transition-delay: 4s;transition-delay: 4s;}.transition-delay-sec4_5 {-webkit-transition-delay: 4.5s;-moz-transition-delay: 4.5s;-o-transition-delay: 4.5s;-ms-transition-delay: 4.5s;transition-delay: 4.5s;}.transition-delay-sec5 {-webkit-transition-delay: 5s;-moz-transition-delay: 5s;-o-transition-delay: 5s;-ms-transition-delay: 5s;transition-delay: 5s;}.transition-delay-sec6 {-webkit-transition-delay: 6s;-moz-transition-delay: 6s;-o-transition-delay: 6s;-ms-transition-delay: 6s;transition-delay: 6s;}.transition-delay-sec7 {-webkit-transition-delay: 7s;-moz-transition-delay: 7s;-o-transition-delay: 7s;-ms-transition-delay: 7s;transition-delay: 7s;}.transition-delay-sec8 {-webkit-transition-delay: 8s;-moz-transition-delay: 8s;-o-transition-delay: 8s;-ms-transition-delay: 8s;transition-delay: 8s;}.transition-delay-sec9 {-webkit-transition-delay: 9s;-moz-transition-delay: 9s;-o-transition-delay: 9s;-ms-transition-delay: 9s;transition-delay: 9s;}.transition-delay-sec10 {-webkit-transition-delay: 10s;-moz-transition-delay: 10s;-o-transition-delay: 10s;-ms-transition-delay: 10s;transition-delay: 10s;}.transition-delay-ms100 {-webkit-transition-delay: 100ms;-moz-transition-delay: 100ms;-o-transition-delay: 100ms;-ms-transition-delay: 100ms;transition-delay: 100ms;}.transition-delay-ms200 {-webkit-transition-delay: 200ms;-moz-transition-delay: 200ms;-o-transition-delay: 200ms;-ms-transition-delay: 200ms;transition-delay: 200ms;}.transition-delay-ms300 {-webkit-transition-delay: 300ms;-moz-transition-delay: 300ms;-o-transition-delay: 300ms;-ms-transition-delay: 300ms;transition-delay: 300ms;}.transition-delay-ms400 {-webkit-transition-delay: 400ms;-moz-transition-delay: 400ms;-o-transition-delay: 400ms;-ms-transition-delay: 400ms;transition-delay: 400ms;}.transition-delay-ms500 {-webkit-transition-delay: 500ms;-moz-transition-delay: 500ms;-o-transition-delay: 500ms;-ms-transition-delay: 500ms;transition-delay: 500ms;}.transition-delay-ms600 {-webkit-transition-delay: 600ms;-moz-transition-delay: 600ms;-o-transition-delay: 600ms;-ms-transition-delay: 600ms;transition-delay: 600ms;}.transition-delay-ms700 {-webkit-transition-delay: 700ms;-moz-transition-delay: 700ms;-o-transition-delay: 700ms;-ms-transition-delay: 700ms;transition-delay: 700ms;}.transition-delay-ms800 {-webkit-transition-delay: 800ms;-moz-transition-delay: 800ms;-o-transition-delay: 800ms;-ms-transition-delay: 800ms;transition-delay: 800ms;}.transition-delay-ms900 {-webkit-transition-delay: 900ms;-moz-transition-delay: 900ms;-o-transition-delay: 900ms;-ms-transition-delay: 900ms;transition-delay: 900ms;}.theme-inverse h1,.theme-inverse h2,.theme-inverse h3,.theme-inverse h4,.theme-inverse h5 {color: #fff;}.theme-inverse a {color: inherit;}.theme-inverse a:hover {color: #a6daff;}.theme-inverse a:active {color: #bfe5ff;}.theme-inverse a.text-muted {color: #b1b1b3;}.theme-inverse hr {background: #555659;}.theme-inverse .mo-identicon {background-color: #555659;color: #fff;}.theme-inverse .menu-row.hover {background: #222326;}.theme-inverse .menu-row.active {color: #fff;background: #222326;}.theme-inverse .menu-row.disabled {opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);}.theme-inverse a.menu-row {color: inherit;}.theme-inverse a.menu-row:hover {background: #222326;}.theme-inverse a.menu-row:active {color: #fff;background: #222326;}.theme-inverse .menu-divider {border-color: #555659;}.theme-inverse .text-color-heading {color: #fff;}.theme-inverse .text-color-body {color: #d7d7d9;}.theme-inverse .text-muted {color: #b1b1b3;}.theme-inverse .text-positive {color: #8ae58a;}.theme-inverse .text-muted-positive {color: #39bf71;}.theme-inverse .text-negative {color: #f99;}.theme-inverse .text-muted-negative {color: #f26161;}.theme-inverse .nav-link,.momentum-body .theme-inverse .nav-link {color: #b1b1b3;}.theme-inverse .nav-link:hover,.momentum-body .theme-inverse .nav-link:hover {color: #a6daff;}.theme-inverse .nav-link:active,.momentum-body .theme-inverse .nav-link:active {color: #bfe5ff;}.theme-inverse a.tab-link,.momentum-body .theme-inverse a.tab-link {color: #d7d7d9;}.theme-inverse a.tab-link:hover,.momentum-body .theme-inverse a.tab-link:hover {border-bottom-color: #969799;color: #fff;}.theme-inverse a.tab-link:active,.momentum-body .theme-inverse a.tab-link:active {border-bottom-color: #d7d7d9;color: #d7d7d9;}.theme-inverse a.tab-link.selected,.momentum-body .theme-inverse a.tab-link.selected {color: #fff;}.theme-inverse .list-row {border-bottom: 1px solid #555659;border-top: 1px solid #555659;}.theme-inverse .upload {background-color: #3b3d3f;border-color: #555659;color: #969799;}.theme-inverse .upload:hover,.theme-inverse .upload.hover {background-color: #707173;}.theme-inverse .border {border-color: #555659;}.theme-inverse .border-top {border-top-color: #555659;}.theme-inverse .border-right {border-right-color: #555659;}.theme-inverse .border-bottom {border-bottom-color: #555659;}.theme-inverse .border-left {border-left-color: #555659;}@media (max-width: 575px) {.display-none-xs {display: none;}.display-inline-xs,.inline-xs {display: inline;}.display-block-cx,.block-xs {display: block;}.display-inline-block-xs,.inline-block-xs {display: inline-block;}.display-table-xs,.table-xs {display: table;}.display-table-cell-xs,.table-cell-xs {display: table-cell;}.display-flex-xs,.flex-xs {display: flex;}}@media (min-width: 576px) {.container,.container-sm {max-width: 540px;width: auto;}.col-sm {flex: 1 1 0%;min-width: 0;width: 100%;}.col-sm-auto {flex: 0 0 auto;width: auto;}.col-sm-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-sm-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-sm-3 {flex: 0 0 25%;max-width: 25%;}.col-sm-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-sm-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-sm-6 {flex: 0 0 50%;max-width: 50%;}.col-sm-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-sm-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-sm-9 {flex: 0 0 75%;max-width: 75%;}.col-sm-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-sm-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-sm-12 {flex: 0 0 100%;max-width: 100%;}.display-none-sm {display: none;}.display-inline-sm {display: inline;}.display-block-sm {display: block;}.display-inline-block-sm {display: inline-block;}.display-table-sm {display: table;}.display-table-cell-sm {display: table-cell;}.display-flex-sm {display: flex;}}@media (min-width: 768px) {.container,.container-sm,.container-md {max-width: 720px;width: auto;}.col-md {flex: 1 1 0%;min-width: 0;width: 100%;}.col-md-auto {flex: 0 0 auto;width: auto;}.col-md-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-md-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-md-3 {flex: 0 0 25%;max-width: 25%;}.col-md-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-md-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-md-6 {flex: 0 0 50%;max-width: 50%;}.col-md-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-md-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-md-9 {flex: 0 0 75%;max-width: 75%;}.col-md-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-md-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-md-12 {flex: 0 0 100%;max-width: 100%;}.display-none-md {display: none;}.display-inline-md {display: inline;}.display-block-md {display: block;}.display-inline-block-md {display: inline-block;}.display-table-md {display: table;}.display-table-cell-md {display: table-cell;}.display-flex-md {display: flex;}}@media (min-width: 992px) {.container,.container-sm,.container-md,.container-lg {max-width: 960px;width: auto;}.col-lg {flex: 1 1 0%;min-width: 0;width: 100%;}.col-lg-auto {flex: 0 0 auto;width: auto;}.col-lg-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-lg-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-lg-3 {flex: 0 0 25%;max-width: 25%;}.col-lg-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-lg-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-lg-6 {flex: 0 0 50%;max-width: 50%;}.col-lg-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-lg-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-lg-9 {flex: 0 0 75%;max-width: 75%;}.col-lg-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-lg-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-lg-12 {flex: 0 0 100%;max-width: 100%;}.display-none-lg {display: none;}.display-inline-lg {display: inline;}.display-block-lg {display: block;}.display-inline-block-lg {display: inline-block;}.display-table-lg {display: table;}.display-table-cell-lg {display: table-cell;}.display-flex-lg {display: flex;}}@media (min-width: 1200px) {.container,.container-sm,.container-md,.container-lg,.container-xl {max-width: 1140px;width: auto;}.col-xl {flex: 1 1 0%;min-width: 0;width: 100%;}.col-xl-auto {flex: 0 0 auto;width: auto;}.col-xl-1 {flex: 0 0 8.333333333333334%;max-width: 8.333333333333334%;}.col-xl-2 {flex: 0 0 16.666666666666668%;max-width: 16.666666666666668%;}.col-xl-3 {flex: 0 0 25%;max-width: 25%;}.col-xl-4 {flex: 0 0 33.333333333333336%;max-width: 33.333333333333336%;}.col-xl-5 {flex: 0 0 41.666666666666664%;max-width: 41.666666666666664%;}.col-xl-6 {flex: 0 0 50%;max-width: 50%;}.col-xl-7 {flex: 0 0 58.333333333333336%;max-width: 58.333333333333336%;}.col-xl-8 {flex: 0 0 66.66666666666667%;max-width: 66.66666666666667%;}.col-xl-9 {flex: 0 0 75%;max-width: 75%;}.col-xl-10 {flex: 0 0 83.33333333333333%;max-width: 83.33333333333333%;}.col-xl-11 {flex: 0 0 91.66666666666667%;max-width: 91.66666666666667%;}.col-xl-12 {flex: 0 0 100%;max-width: 100%;}.display-none-xl {display: none;}.display-inline-xl {display: inline;}.display-block-xl {display: block;}.display-inline-block-xl {display: inline-block;}.display-table-xl {display: table;}.display-table-cell-xl {display: table-cell;}.display-flex-xl {display: flex;}}html {position: relative;min-height: 100%;}body {background: #f9f9f9;color: #515357;padding-top: 70px;padding-bottom: 250px;}a,a:visited {color: #737578;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Bold.ttf") format('truetype');font-style: normal;font-weight: bold;text-rendering: optimizeLegibility;}@font-face {font-family: Lato;src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot");src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.eot?#iefix") format('embedded-opentype');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.woff") format('woff');src: url("https://cdn.lever.co/fonts/Lato2/Lato-Regular.ttf") format('truetype');font-style: normal;font-weight: normal;text-rendering: optimizeLegibility;}body,.application-question input,.application-additional input,.application-question textarea,.application-additional textarea,.application-question select,.application-additional select,.eeo-light-text,h5.eeo-paragraph-heading,.list .filter-popup {color: #515357;font: normal 400 16px/1.8 Lato;}h1,h2,h3,h4,p,h5,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 0;padding: 0;display: block;}h1 {font: normal 700 48px/1.4 Lato;color: #fff;text-transform: uppercase;letter-spacing: 1px;}h2,h5 {font: normal 400 36px/1.4 Lato;color: #515357;text-transform: none;letter-spacing: 0px;}h3 {font: normal 700 18px/1.4 "Lato";color: #515357;}h4 {font: normal 700 16px/1.4 Lato;text-transform: uppercase;letter-spacing: 1px;color: #515357;}h5 {font-size: 24px;margin-right: 115px;overflow: hidden;-webkit-transition: color 150ms;-moz-transition: color 150ms;-o-transition: color 150ms;-ms-transition: color 150ms;transition: color 150ms;}h2,h3,h4 {margin: 17.5px 0;}p,.main-footer,.application .application-label,.eeo-survey .application-label,.application .application-field label,.eeo-survey .application-field label,.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {margin: 17.5px 0;}p > a,.postings-link {text-decoration: underline;color: #737578;}p > a:hover,.postings-link:hover {color: #579eee;}p > a:active,.postings-link:active,p > a:focus,.postings-link:focus {color: #3c6ea6;}.page-full-width {width: 100%;}.page-centered,.g-recaptcha div,.h-captcha-spacing {display: block;margin: 0 auto;max-width: 1080px;}.content-wrapper {min-height: 100%;}.content {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;min-height: 100%;position: relative;width: 100%;}.row {left: 0;position: absolute;right: 0;}.column-wrapper {display: table;height: 100%;width: 100%;}.table-row {display: table-row;}.column {display: table-cell;position: relative;vertical-align: middle;}.third {width: 33.33%;}.two-thirds {-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;padding-left: 40px;width: 66.67%;}.section-wrapper {padding: 0 30px;}.section {padding: 20px 0;position: relative;}.narrow-section,.application .section,.eeo-survey .section,.list .section,.show .section {max-width: 760px;padding-left: 0;padding-right: 0;}.accent-section {background: #fff;}.accent-section.small-accent {padding: 0 30px;}.accent-section .posting-categories {margin: 20px 0;}.accent-section .posting-category {display: inline-block;font-size: 14px;margin-right: 10px;}.split-width-container,.show .posting-header {display: block;}.left-block,.right-block,.left-float,.right-float,.full-block {display: block;width: auto;}.left-block {overflow: hidden;}.right-float {float: right;margin-left: 10px;}.right-block {overflow: hidden;}.left-float {float: left;margin-right: 10px;}.full-block {width: 100%;}.template-btn,.template-btn-submit,.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {font: normal 700 14px/1.4 Lato;text-transform: uppercase;letter-spacing: 2px;text-align: center;border-radius: 3px;color: #fff;background: #00a1dc;height: auto;position: relative;display: inline-block;margin: 0;font-size: 14px;font-weight: normal;line-height: 1.33;padding: 10px 15px;text-align: center;white-space: nowrap;vertical-align: middle;cursor: pointer;border: 1px solid #dcdcdc;border-radius: 3px;-webkit-user-select: none;-moz-user-select: none;-ms-user-select: none;user-select: none;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.template-btn .filename,.template-btn-submit .filename,.template-btn-utility .filename,.sort-category .filename,.application .application-field .upload-file-overlay .filename,.eeo-survey .application-field .upload-file-overlay .filename,.list .filter-button-wrapper .filter-button .filename,.template-btn .default-label,.template-btn-submit .default-label,.template-btn-utility .default-label,.sort-category .default-label,.application .application-field .upload-file-overlay .default-label,.eeo-survey .application-field .upload-file-overlay .default-label,.list .filter-button-wrapper .filter-button .default-label {line-height: 1.33;display: block;overflow: hidden;}.template-btn:visited,.template-btn-submit:visited,.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {color: #fff;}.template-btn .icon >svg,.template-btn-submit .icon >svg,.template-btn-utility .icon >svg,.sort-category .icon >svg,.application .application-field .upload-file-overlay .icon >svg,.eeo-survey .application-field .upload-file-overlay .icon >svg,.list .filter-button-wrapper .filter-button .icon >svg {fill: #fff;}.template-btn:hover,.template-btn-submit:hover,.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {color: #fff;}.template-btn:active,.template-btn-submit:active,.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn:focus,.template-btn-submit:focus,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #00709a;}.template-btn-submit {color: #fff;background: #00a1dc;border-color: #0098d1;}.template-btn-submit .icon >svg {fill: #fff;}.template-btn-submit:visited {color: #fff;}.template-btn-submit:hover {background: #0090c6;}.template-btn-submit:active,.template-btn-submit:focus {background: #00709a;}.template-btn-submit.cerulean {background-color: #0c92f3;border-color: #0b8ae6;}.template-btn-submit.cerulean:hover {background: #0a83da;}.template-btn-submit.cerulean:active,.template-btn-submit.cerulean:focus {background: #0866aa;}.template-btn-submit.teal {background-color: #1cadba;border-color: #1aa4b0;}.template-btn-submit.teal:hover {background: #199ba7;}.template-btn-submit.teal:active,.template-btn-submit.teal:focus {background: #137982;}.template-btn-submit.shamrock {background-color: #39bf71;border-color: #36b56b;}.template-btn-submit.shamrock:hover {background: #33ab65;}.template-btn-submit.shamrock:active,.template-btn-submit.shamrock:focus {background: #27854f;}.template-btn-submit.golden-poppy {background-color: #ffa60d;border-color: #f29d0c;}.template-btn-submit.golden-poppy:hover {background: #e5950b;}.template-btn-submit.golden-poppy:active,.template-btn-submit.golden-poppy:focus {background: #b27409;}.template-btn-submit.ruby {background-color: #d94141;border-color: #ce3d3d;}.template-btn-submit.ruby:hover {background: #c33a3a;}.template-btn-submit.ruby:active,.template-btn-submit.ruby:focus {background: #972d2d;}.template-btn-submit.ash {background-color: #969799;border-color: #8e8f91;}.template-btn-submit.ash:hover {background: #878789;}.template-btn-submit.ash:active,.template-btn-submit.ash:focus {background: #69696b;}.template-btn-submit.black {background-color: #000;border-color: #000;}.template-btn-submit.black:hover {background: #000;}.template-btn-submit.black:active,.template-btn-submit.black:focus {background: #000;}.template-btn-utility,.sort-category,.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay,.list .filter-button-wrapper .filter-button {background: #ebecf0;color: #9696a2;border: 1px solid #dfe0e4;}.template-btn-utility >svg,.sort-category >svg,.application .application-field .upload-file-overlay >svg,.eeo-survey .application-field .upload-file-overlay >svg,.list .filter-button-wrapper .filter-button >svg {fill: #9696a2;}.template-btn-utility:visited,.sort-category:visited,.application .application-field .upload-file-overlay:visited,.eeo-survey .application-field .upload-file-overlay:visited,.list .filter-button-wrapper .filter-button:visited {color: #9696a2;background: #ebecf0;}.template-btn-utility:hover,.sort-category:hover,.application .application-field .upload-file-overlay:hover,.eeo-survey .application-field .upload-file-overlay:hover,.list .filter-button-wrapper .filter-button:hover {background: #dfe0e4;color: #5a5a61;}.template-btn-utility:active,.sort-category:active,.application .application-field .upload-file-overlay:active,.eeo-survey .application-field .upload-file-overlay:active,.list .filter-button-wrapper .filter-button:active,.template-btn-utility:focus,.sort-category:focus,.application .application-field .upload-file-overlay:focus,.eeo-survey .application-field .upload-file-overlay:focus,.list .filter-button-wrapper .filter-button:focus {background: #d3d4d8;color: #5a5a61;}.template-btn-utility.has-file,.sort-category.has-file,.application .application-field .upload-file-overlay.has-file,.eeo-survey .application-field .upload-file-overlay.has-file,.list .filter-button-wrapper .filter-button.has-file {background: #dadbdf;}.template-btn .icon,.template-btn-submit .icon,.template-btn-utility .icon,.sort-category .icon,.application .application-field .upload-file-overlay .icon,.eeo-survey .application-field .upload-file-overlay .icon,.list .filter-button-wrapper .filter-button .icon {position: absolute;left: 15px;top: calc(50% - 8px);}.posting-btn-submit {padding: 5px 15px;}.main-header {background: #fff;color: #515357;}.main-header.section-wrapper,.main-header .section {padding-top: 0px;padding-bottom: 0px;}.main-header .main-header-logo {margin: 17.5px 0px;display: inline-block;}.main-header .main-header-logo img {height: 35px;}.main-header .mobile-menu svg >path {fill: #515357;}.main-header .main-header-content {display: block;height: 100%;margin: 0px auto;color: #515357;}.main-header .main-header-content .main-header-company {display: inline-block;height: 70px;vertical-align: middle;font-family: Lato;color: #515357;}.main-header {top: 0;height: 70px;}.main-header .main-logo,.main-header .mobile-menu {position: absolute;left: 30px;}.main-header .main-logo img,.main-header .mobile-menu img {height: 100%;position: absolute;}.main-header .main-logo {top: 50%;margin-top: -0.175px;height: 0.5;}.main-header .mobile-menu {position: absolute;right: 0px;top: 50%;margin-top: -0.15px;height: 0.6;left: auto;right: 30px;}.main-header .mobile-menu img {right: 0px;}.main-header .main-header-content .main-header-company {line-height: 70px;}.main-header .main-header-content .main-header-company .icon,.main-header .main-header-content .main-header-company span {height: 70px;display: inline-block;float: left;height: 70px;}.main-header .main-header-content .main-header-company .icon {margin-right: 10px;}@media screen {.main-header {position: fixed;z-index: 100;top: 0;overflow: hidden;}}.header-comfortable {margin-top: 40px;}.header-comfortable .main-header-logo img {height: 77px;}.header-comfortable .main-header {height: 110px;}.main-footer {margin: 0;color: #7f838a;background: #edeef1;}.main-footer .image-link {display: inline-block;color: #7f838a;margin: 40px 0px;}.main-footer .image-link span,.main-footer .image-link img {display: inline-block;position: relative;height: 24px;}.main-footer .image-link span {margin-right: 10px;}.main-footer .image-link img {vertical-align: -6px;}.main-footer .image-link:hover,.main-footer .image-link:visited {color: #7f838a;}.main-footer p {color: #7f838a;}.main-footer a {color: #579eee;border-bottom: 1px solid #78b1f1;text-decoration: none;}.main-footer a:visited {color: #579eee;}.main-footer a:hover {color: #4e8ed6;}.main-footer a.image-link {border-bottom: none;}.main-footer {position: absolute;bottom: 0;width: 100%;height: 250px;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.main-footer-text {text-align: center;padding: 40px 30px;}.main-footer-text p {display: block;max-width: 500px;margin: 0px auto;}.posting-header h2 {margin-top: 0px;}.posting-page .section.page-centered li {margin: 8px 0px 8px 17px;list-style-position: outside;}.posting-page .section.page-centered ul li {list-style-type: disc;}.medium-utility-label,.small-utility-label {color: #808080;font: normal 700 16px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.large-category-label,.medium-category-label,.small-category-label,.button-utility-label {color: #808080;font: normal 700 24px/1.4 Lato;letter-spacing: 1px;text-transform: uppercase;}.medium-category-label,.button-utility-label {font-size: 14px;}.small-utility-label {font-size: 12px;line-height: 1.4;}.large-category-header {font: normal 700 30px/1.4 Lato;letter-spacing: 1px;margin-bottom: 25px;text-transform: uppercase;}.medium-category-label.capitalize-labels {text-transform: capitalize;}.small-category-label {font-size: 12px;line-height: 1.4;}.button-utility-label {text-transform: none;}.vertical-line,.horizontal-line {border-color: #e2e2e2;}.vertical-line {position: absolute;left: 0px;top: 30%;height: 40%;width: 1px;border-left-width: 1px;border-left-style: solid;}.horizontal-line {margin: 20px auto 20px auto;width: 80px;height: 1px;border-bottom-width: 1px;border-bottom-style: solid;}.confirmation-message {text-align: center;}.confirmation-message .template-btn-submit {margin-top: 16px;}.cc-window{opacity:1;-webkit-transition:opacity 1s ease;transition:opacity 1s ease}.cc-window.cc-invisible{opacity:0}.cc-animate.cc-revoke{-webkit-transition:transform 1s ease;-webkit-transition:-webkit-transform 1s ease;transition:-webkit-transform 1s ease;transition:transform 1s ease;transition:transform 1s ease,-webkit-transform 1s ease}.cc-animate.cc-revoke.cc-top{-webkit-transform:translateY(-2em);transform:translateY(-2em)}.cc-animate.cc-revoke.cc-bottom{-webkit-transform:translateY(2em);transform:translateY(2em)}.cc-animate.cc-revoke.cc-active.cc-top{-webkit-transform:translateY(0);transform:translateY(0)}.cc-animate.cc-revoke.cc-active.cc-bottom{-webkit-transform:translateY(0);transform:translateY(0)}.cc-revoke:hover{-webkit-transform:translateY(0);transform:translateY(0)}.cc-grower{max-height:0;overflow:hidden;-webkit-transition:max-height 1s;transition:max-height 1s}.cc-revoke,.cc-window{position:fixed;overflow:hidden;-webkit-box-sizing:border-box;box-sizing:border-box;font-family:Helvetica,Calibri,Arial,sans-serif;font-size:16px;line-height:1.5em;display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:nowrap;flex-wrap:nowrap;z-index:9999}.cc-window.cc-static{position:static}.cc-window.cc-floating{padding:2em;max-width:24em;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner{padding:1em 1.8em;width:100%;-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row}.cc-revoke{padding:.5em}.cc-revoke:hover{text-decoration:underline}.cc-header{font-size:18px;font-weight:700}.cc-btn,.cc-close,.cc-link,.cc-revoke{cursor:pointer}.cc-link{opacity:.8;display:inline-block;padding:.2em;text-decoration:underline}.cc-link:hover{opacity:1}.cc-link:active,.cc-link:visited{color:initial}.cc-btn{display:block;padding:.4em .8em;font-size:.9em;font-weight:700;border-width:2px;border-style:solid;text-align:center;white-space:nowrap}.cc-highlight .cc-btn:first-child{background-color:transparent;border-color:transparent}.cc-highlight .cc-btn:first-child:focus,.cc-highlight .cc-btn:first-child:hover{background-color:transparent;text-decoration:underline}.cc-close{display:block;position:absolute;top:.5em;right:.5em;font-size:1.6em;opacity:.9;line-height:.75}.cc-close:focus,.cc-close:hover{opacity:1}.cc-revoke.cc-top{top:0;left:3em;border-bottom-left-radius:.5em;border-bottom-right-radius:.5em}.cc-revoke.cc-bottom{bottom:0;left:3em;border-top-left-radius:.5em;border-top-right-radius:.5em}.cc-revoke.cc-left{left:3em;right:unset}.cc-revoke.cc-right{right:3em;left:unset}.cc-top{top:1em}.cc-left{left:1em}.cc-right{right:1em}.cc-bottom{bottom:1em}.cc-floating>.cc-link{margin-bottom:1em}.cc-floating .cc-message{display:block;margin-bottom:1em}.cc-window.cc-floating .cc-compliance{-webkit-box-flex:1;-ms-flex:1 0 auto;flex:1 0 auto}.cc-window.cc-banner{-webkit-box-align:center;-ms-flex-align:center;align-items:center}.cc-banner.cc-top{left:0;right:0;top:0}.cc-banner.cc-bottom{left:0;right:0;bottom:0}.cc-banner .cc-message{display:block;-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto;max-width:100%;margin-right:1em}.cc-compliance{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-ms-flex-line-pack:justify;align-content:space-between}.cc-floating .cc-compliance>.cc-btn{-webkit-box-flex:1;-ms-flex:1;flex:1}.cc-btn+.cc-btn{margin-left:.5em}@media print{.cc-revoke,.cc-window{display:none}}@media screen and (max-width:900px){.cc-btn{white-space:normal}}@media screen and (max-width:414px) and (orientation:portrait),screen and (max-width:736px) and (orientation:landscape){.cc-window.cc-top{top:0}.cc-window.cc-bottom{bottom:0}.cc-window.cc-banner,.cc-window.cc-floating,.cc-window.cc-left,.cc-window.cc-right{left:0;right:0}.cc-window.cc-banner{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.cc-window.cc-banner .cc-compliance{-webkit-box-flex:1;-ms-flex:1 1 auto;flex:1 1 auto}.cc-window.cc-floating{max-width:none}.cc-window .cc-message{margin-bottom:1em}.cc-window.cc-banner{-webkit-box-align:unset;-ms-flex-align:unset;align-items:unset}.cc-window.cc-banner .cc-message{margin-right:0}}.cc-floating.cc-theme-classic{padding:1.2em;border-radius:5px}.cc-floating.cc-type-info.cc-theme-classic .cc-compliance{text-align:center;display:inline;-webkit-box-flex:0;-ms-flex:none;flex:none}.cc-theme-classic .cc-btn{border-radius:5px}.cc-theme-classic .cc-btn:last-child{min-width:140px}.cc-floating.cc-type-info.cc-theme-classic .cc-btn{display:inline-block}.cc-theme-edgeless.cc-window{padding:0}.cc-floating.cc-theme-edgeless .cc-message{margin:2em;margin-bottom:1.5em}.cc-banner.cc-theme-edgeless .cc-btn{margin:0;padding:.8em 1.8em;height:100%}.cc-banner.cc-theme-edgeless .cc-message{margin-left:1em}.cc-floating.cc-theme-edgeless .cc-btn+.cc-btn{margin-left:0}.cc-btn {border-width: 1px;display: inline;font-weight: normal;}.cc-link {color: inherit;}.cc-link:hover {color: #a6daff;}.cc-revoke {display: none;}.cc-window,.cc-revoke {background: #3b3d3f;border-radius: 8px 8px 0 0;color: #d7d7d9;font: inherit;}.cc-window.cc-banner,.cc-window.cc-floating {padding: 16px;}.cc-window.cc-floating {bottom: 0;min-width: 100%;}.cc-window {padding: 16px;}.cc-window .cc-mobile {display: none;}.cc-window .message-inverse {background: #222326;border-radius: 8px 8px 0 0;}.cc-window .momentum-body {margin: -16px;width: calc(100% + 32px);}.cc-window .momentum-body .cookie-banner-link {white-space: nowrap;}.cc-window .momentum-body .message {padding: 16px 16px 16px 48px;}.cc-window .momentum-body .message .icon {font-size: 24px;left: 16px;top: 16px;}.cc-window .message-buttons {margin-right: 16px;margin-top: 12px;}.cc-window h4 {color: #fff;margin-bottom: 4px;}@media screen and (max-width: 1150px) {.cc-window .cc-desktop {display: none;}.cc-window .cc-mobile {display: block;margin-top: 16px;}.cc-window .message {display: flex;}}.error-section {text-align: center;}.error-section img {margin-top: 70px;margin-bottom: 16px;}.application-question input,.application-additional input,.application-question textarea,.application-additional textarea {border-color: #e2e2e2;}.application-question input:active,.application-additional input:active,.application-question textarea:active,.application-additional textarea:active,.application-question input:focus,.application-additional input:focus,.application-question textarea:focus,.application-additional textarea:focus {border-color: #7f838a;}.application-question select,.application-additional select {background: #e2e2e2;border-color: transparent;}.application-question select:hover,.application-additional select:hover {background: #c0c0c0;}.application-question.custom-question,.application-additional.custom-question {display: grid;}.application-question.custom-question .application-label.multiple-choice,.application-additional.custom-question .application-label.multiple-choice,.application-question.custom-question .application-label.multiple-select,.application-additional.custom-question .application-label.multiple-select,.application-question.custom-question .application-label.textarea,.application-additional.custom-question .application-label.textarea,.application-question.custom-question .application-label.dropdown,.application-additional.custom-question .application-label.dropdown {margin-bottom: 0px;}.application-question.custom-question .application-field,.application-additional.custom-question .application-field {display: inline-block;}.application-question.custom-question .application-field input[type=text],.application-additional.custom-question .application-field input[type=text],.application-question.custom-question .application-field input[type=email],.application-additional.custom-question .application-field input[type=email],.application-question.custom-question .application-field input[type=tel],.application-additional.custom-question .application-field input[type=tel] {margin-top: 0px;}.application-question.custom-question .application-field input[type=radio],.application-additional.custom-question .application-field input[type=radio],.application-question.custom-question .application-field input[type=checkbox],.application-additional.custom-question .application-field input[type=checkbox] {left: 0px;}.application-question.custom-question .application-field .upload-file-overlay,.application-additional.custom-question .application-field .upload-file-overlay {margin-bottom: 17.5px;}.application-question.custom-question .application-field ul label,.application-additional.custom-question .application-field ul label {padding-left: 30px;}.application .application-question,.eeo-survey .application-question {list-style-type: none;padding: 0px 0px;}.application .application-label,.eeo-survey .application-label {font-size: 16px;line-height: 1.4;vertical-align: middle;width: 100%;}.application .application-label .description,.eeo-survey .application-label .description {font-size: 12px;margin-bottom: 0;}.application .application-label label,.eeo-survey .application-label label {position: relative;}.application .application-label.multiple-choice,.eeo-survey .application-label.multiple-choice,.application .application-label.multiple-select,.eeo-survey .application-label.multiple-select,.application .application-label.textarea,.eeo-survey .application-label.textarea {vertical-align: top;}.application .application-label.text,.eeo-survey .application-label.text {vertical-align: bottom;}.application .application-field,.eeo-survey .application-field {position: relative;-webkit-box-sizing: border-box;-moz-box-sizing: border-box;box-sizing: border-box;}.application .application-field input[type=text],.eeo-survey .application-field input[type=text],.application .application-field select,.eeo-survey .application-field select,.application .application-field input[type=email],.eeo-survey .application-field input[type=email],.application .application-field input[type=tel],.eeo-survey .application-field input[type=tel] {display: inline-block;width: 100%;}.application .application-field input[type=text][disabled],.eeo-survey .application-field input[type=text][disabled],.application .application-field select[disabled],.eeo-survey .application-field select[disabled],.application .application-field input[type=email][disabled],.eeo-survey .application-field input[type=email][disabled],.application .application-field input[type=tel][disabled],.eeo-survey .application-field input[type=tel][disabled] {background-color: #e2e2e2;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {cursor: pointer;outline: none;}.application .application-field .icon-caret-down,.eeo-survey .application-field .icon-caret-down {height: 16px;width: 16px;position: absolute;right: 10px;margin-top: -8px;top: 50%;}.application .application-field ul,.eeo-survey .application-field ul {list-style-type: none;}.application .application-field label,.eeo-survey .application-field label {padding-left: 40px;position: relative;cursor: pointer;}.application .application-field label .application-answer-alternative,.eeo-survey .application-field label .application-answer-alternative {color: #83868c;}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio] {-webkit-appearance: none;-moz-appearance: none;appearance: none;width: 20px;height: 20px;border-radius: 10px;position: relative;border: 1px solid #e2e2e2;}.application .application-field input[type=radio]:active,.eeo-survey .application-field input[type=radio]:active {background: #ebecf0;}.application .application-field input[type=radio]:checked::after,.eeo-survey .application-field input[type=radio]:checked::after {position: absolute;content: "";height: 20px;width: 20px;left: 0;top: 0;border-radius: 10px;background-color: #00a1dc;}.application .application-field input[type=radio]:checked + span,.eeo-survey .application-field input[type=radio]:checked + span,.application .application-field input[type=checkbox]:checked + span,.eeo-survey .application-field input[type=checkbox]:checked + span {color: #515357;}.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {width: 20px;height: 20px;border: 1px solid #e2e2e2;-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-field input[type=checkbox]:active,.eeo-survey .application-field input[type=checkbox]:active {background: #ebecf0;}.application .application-field input[type=checkbox]:checked::after,.eeo-survey .application-field input[type=checkbox]:checked::after {position: absolute;content: "";left: 15%;top: -10%;height: 40%;width: 90%;border-bottom: 4px solid #00a1dc;border-left: 4px solid #00a1dc;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);}.application .application-field input[type=radio],.eeo-survey .application-field input[type=radio],.application .application-field input[type=checkbox],.eeo-survey .application-field input[type=checkbox] {position: absolute;left: 10px;top: 2px;}.application .application-field .application-university,.eeo-survey .application-field .application-university {position: relative;}.application .application-field .application-university .select2-container,.eeo-survey .application-field .application-university .select2-container {height: 40px;}.application .application-field .application-university .select2-container .select2-selection,.eeo-survey .application-field .application-university .select2-container .select2-selection {padding: 4px 4px 4px 7px;height: 40px;}.application .application-field .application-university .select2-container .select2-selection:active,.eeo-survey .application-field .application-university .select2-container .select2-selection:active,.application .application-field .application-university .select2-container .select2-selection:focus,.eeo-survey .application-field .application-university .select2-container .select2-selection:focus {outline: none;border: 1px solid #7f838a;}.application .application-field .application-university .select2-container .select2-selection span,.eeo-survey .application-field .application-university .select2-container .select2-selection span {font-size: 16px !important;}.application .application-field .application-university .select2-container .select2-selection__arrow,.eeo-survey .application-field .application-university .select2-container .select2-selection__arrow {top: 7px;}.application .application-field .application-dropdown,.eeo-survey .application-field .application-dropdown {position: relative;}.application .application-field .application-dropdown select,.eeo-survey .application-field .application-dropdown select {text-indent: 0.01px;-o-text-overflow: '';text-overflow: '';padding-right: 40px;}.application .application-field .application-dropdown select::-ms-expand,.eeo-survey .application-field .application-dropdown select::-ms-expand {display: none;}.application .application-field .application-dropdown::after,.eeo-survey .application-field .application-dropdown::after {position: absolute;content: "";right: 15px;top: 26px;height: 15px;width: 15px;border-bottom: 1px solid #7f838a;border-left: 1px solid #7f838a;border-color: #72767d;-webkit-transform: rotate(-45deg);-moz-transform: rotate(-45deg);-o-transform: rotate(-45deg);-ms-transform: rotate(-45deg);transform: rotate(-45deg);pointer-events: none;}.application .application-field .upload-file-overlay,.eeo-survey .application-field .upload-file-overlay {max-width: 100%;padding-left: 41px;}.application .application-field .upload-file-overlay .icon-paperclip,.eeo-survey .application-field .upload-file-overlay .icon-paperclip {position: absolute;left: 15px;}.application .application-field input[type=file],.eeo-survey .application-field input[type=file] {position: absolute;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);top: 0;left: 0;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select,.application .application-question .application-answer-alternative,.eeo-survey .application-question .application-answer-alternative,.application .application-additional .application-answer-alternative,.eeo-survey .application-additional .application-answer-alternative {font-size: 16px;line-height: 1.4;}.application .application-question input[type=text],.eeo-survey .application-question input[type=text],.application .application-additional input[type=text],.eeo-survey .application-additional input[type=text],.application .application-question input[type=email],.eeo-survey .application-question input[type=email],.application .application-additional input[type=email],.eeo-survey .application-additional input[type=email],.application .application-question input[type=tel],.eeo-survey .application-question input[type=tel],.application .application-additional input[type=tel],.eeo-survey .application-additional input[type=tel],.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea,.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {border-radius: 3px;border-width: 1px;border-style: solid;height: 40px;padding: 4px 4px 4px 15px;-webkit-transition: 1px solid #e3e4e6 150ms, background 150ms;-moz-transition: 1px solid #e3e4e6 150ms, background 150ms;-o-transition: 1px solid #e3e4e6 150ms, background 150ms;-ms-transition: 1px solid #e3e4e6 150ms, background 150ms;transition: 1px solid #e3e4e6 150ms, background 150ms;}.application .application-question input[type=text]:active,.eeo-survey .application-question input[type=text]:active,.application .application-additional input[type=text]:active,.eeo-survey .application-additional input[type=text]:active,.application .application-question input[type=email]:active,.eeo-survey .application-question input[type=email]:active,.application .application-additional input[type=email]:active,.eeo-survey .application-additional input[type=email]:active,.application .application-question input[type=tel]:active,.eeo-survey .application-question input[type=tel]:active,.application .application-additional input[type=tel]:active,.eeo-survey .application-additional input[type=tel]:active,.application .application-question textarea:active,.eeo-survey .application-question textarea:active,.application .application-additional textarea:active,.eeo-survey .application-additional textarea:active,.application .application-question select:active,.eeo-survey .application-question select:active,.application .application-additional select:active,.eeo-survey .application-additional select:active,.application .application-question input[type=text]:focus,.eeo-survey .application-question input[type=text]:focus,.application .application-additional input[type=text]:focus,.eeo-survey .application-additional input[type=text]:focus,.application .application-question input[type=email]:focus,.eeo-survey .application-question input[type=email]:focus,.application .application-additional input[type=email]:focus,.eeo-survey .application-additional input[type=email]:focus,.application .application-question input[type=tel]:focus,.eeo-survey .application-question input[type=tel]:focus,.application .application-additional input[type=tel]:focus,.eeo-survey .application-additional input[type=tel]:focus,.application .application-question textarea:focus,.eeo-survey .application-question textarea:focus,.application .application-additional textarea:focus,.eeo-survey .application-additional textarea:focus,.application .application-question select:focus,.eeo-survey .application-question select:focus,.application .application-additional select:focus,.eeo-survey .application-additional select:focus {outline: none;}.application .application-question input.location-input,.eeo-survey .application-question input.location-input,.application .application-additional input.location-input,.eeo-survey .application-additional input.location-input {margin-bottom: 0;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload,.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {width: 230px;height: 40px;}.application .application-question .visible-resume-upload,.eeo-survey .application-question .visible-resume-upload,.application .application-additional .visible-resume-upload,.eeo-survey .application-additional .visible-resume-upload {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .visible-resume-upload .icon,.eeo-survey .application-question .visible-resume-upload .icon,.application .application-additional .visible-resume-upload .icon,.eeo-survey .application-additional .visible-resume-upload .icon {position: absolute;}.application .application-question .visible-resume-upload .resume-upload-name,.eeo-survey .application-question .visible-resume-upload .resume-upload-name,.application .application-additional .visible-resume-upload .resume-upload-name,.eeo-survey .application-additional .visible-resume-upload .resume-upload-name {vertical-align: middle;display: inline-block;line-height: 40px;white-space: nowrap;overflow: hidden;-o-text-overflow: ellipsis;text-overflow: ellipsis;margin-left: 24px;margin-bottom: 3px;}.application .application-question .resume-upload-filename,.eeo-survey .application-question .resume-upload-filename,.application .application-additional .resume-upload-filename,.eeo-survey .application-additional .resume-upload-filename {margin: 8px 0px;display: inline-block;font-size: 14px;}.application .application-question input.invisible-resume-upload,.eeo-survey .application-question input.invisible-resume-upload,.application .application-additional input.invisible-resume-upload,.eeo-survey .application-additional input.invisible-resume-upload {position: absolute;top: 0px;left: 0px;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);cursor: pointer;}.application .application-question input.invisible-resume-upload:hover,.eeo-survey .application-question input.invisible-resume-upload:hover,.application .application-additional input.invisible-resume-upload:hover,.eeo-survey .application-additional input.invisible-resume-upload:hover {border-color: #f00;}.application .application-question .linkedin-auth-button,.eeo-survey .application-question .linkedin-auth-button,.application .application-additional .linkedin-auth-button,.eeo-survey .application-additional .linkedin-auth-button {position: relative;margin-right: 15px;padding-left: 41px;}.application .application-question .linkedin-auth-button.added,.eeo-survey .application-question .linkedin-auth-button.added,.application .application-additional .linkedin-auth-button.added,.eeo-survey .application-additional .linkedin-auth-button.added {background: #dadbdf;}.application .application-question textarea,.eeo-survey .application-question textarea,.application .application-additional textarea,.eeo-survey .application-additional textarea {padding-top: 10px;resize: vertical;width: 100%;height: 130px;}.application .application-question select,.eeo-survey .application-question select,.application .application-additional select,.eeo-survey .application-additional select {-webkit-appearance: none;-moz-appearance: none;appearance: none;}.application .application-question .dropdown-container,.eeo-survey .application-question .dropdown-container,.application .application-additional .dropdown-container,.eeo-survey .application-additional .dropdown-container {display: none;z-index: 1;overflow-y: auto;position: absolute;max-height: 200px;font-size: 14px;font-family: Meta;letter-spacing: 1px;}.application .application-question .dropdown-loading-results,.eeo-survey .application-question .dropdown-loading-results,.application .application-additional .dropdown-loading-results,.eeo-survey .application-additional .dropdown-loading-results {display: none;}.application .application-question .dropdown-no-results,.eeo-survey .application-question .dropdown-no-results,.application .application-additional .dropdown-no-results,.eeo-survey .application-additional .dropdown-no-results {display: none;}.application .application-question .dropdown-location:hover,.eeo-survey .application-question .dropdown-location:hover,.application .application-additional .dropdown-location:hover,.eeo-survey .application-additional .dropdown-location:hover,.application .application-question .dropdown-location-active,.eeo-survey .application-question .dropdown-location-active,.application .application-additional .dropdown-location-active,.eeo-survey .application-additional .dropdown-location-active {background-color: #000;}.application .required,.eeo-survey .required {display: inline-block;color: #ff794f;margin-left: 4px;font-size: 9px;padding-bottom: 0px;position: absolute;}.application .error-message,.eeo-survey .error-message {background: #ff794f;color: #fff;border-radius: 3px;padding: 5px 15px;width: 700px;max-width: 100%;}.resume-upload-failure,.resume-upload-working,.resume-upload-success,.linkedin-login-success {display: none;cursor: default;position: absolute;top: 0;left: 260px;}.resume-upload-working {cursor: wait;}.resume-upload-success,.linkedin-login-success {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 1s;-webkit-animation-name: fadein;}.resume-upload-failure {-webkit-animation-timing-function: ease-in;-webkit-animation-duration: 4s;-webkit-animation-name: fadeout;opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);display: none;}.resume-upload-failure .resume-upload-label {color: #ff9000;font-size: 13px;font-weight: bold;line-height: 1.8;opacity: 0.5;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";filter: alpha(opacity=50);width: 250px;}.resume-upload-oversize {position: relative;display: none;}.resume-upload-label,.linkedin-login-label {position: absolute;line-height: 40px;display: inline-block;height: 40px;margin-left: 15px;width: 230px;}.loading-indicator {display: inline-block;opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);border-radius: 40px;-webkit-animation: loading 1.5s infinite linear;-moz-animation: loading 1.5s infinite linear;-o-animation: loading 1.5s infinite linear;-ms-animation: loading 1.5s infinite linear;animation: loading 1.5s infinite linear;border: 6px solid #00a1dc;border-top: 6px solid rgba(0,0,0,0);border-left: 6px solid rgba(0,0,0,0);width: 40px;height: 40px;}.loading-indicator.completed {border-left: 6px solid #515357;border-right: 6px solid #515357;border-top: 6px solid #515357;border-bottom: 6px solid #515357;-webkit-animation: none;-moz-animation: none;-o-animation: none;-ms-animation: none;animation: none;text-align: center;}.loading-indicator .icon-checkmark {vertical-align: middle;}.loading-indicator .icon-checkmark >path {fill: #515357;}.application-form h4 {margin: 40px 0;}.awli-button-container {display: inline-block;overflow: hidden;position: relative;vertical-align: middle;}.awli-button-container .iframe-mask {position: absolute;left: 0;background-color: #f9f9f9;z-index: 1;}.awli-button-container .iframe-mask.disclaimer-mask {top: -50px;width: 243px;height: 40px;}.awli-button-container .iframe-mask.button-mask {pointer-events: none;width: 243px;height: 100%;}.awli-button,.awli-button:active,.awli-button:focus {position: relative;margin-right: 15px;padding-left: 41px;padding-right: 0;width: 243px;background: #0073b1;border-color: #0073b1;color: #fff;z-index: 10;outline: none;}.awli-button.button-masked,.awli-button:active.button-masked,.awli-button:focus.button-masked {pointer-events: none;}.awli-button.button-masked > div,.awli-button:active.button-masked > div,.awli-button:focus.button-masked > div {pointer-events: none;}.awli-button.button-masked > div > *,.awli-button:active.button-masked > div > *,.awli-button:focus.button-masked > div > * {pointer-events: none;}.awli-button.state-loading > .loading,.awli-button:active.state-loading > .loading,.awli-button:focus.state-loading > .loading {display: block;}.awli-button.state-loading > .ready,.awli-button:active.state-loading > .ready,.awli-button:focus.state-loading > .ready {display: none;}.awli-button.state-loading > .completed,.awli-button:active.state-loading > .completed,.awli-button:focus.state-loading > .completed {display: none;}.awli-button.state-ready > .loading,.awli-button:active.state-ready > .loading,.awli-button:focus.state-ready > .loading {display: none;}.awli-button.state-ready > .ready,.awli-button:active.state-ready > .ready,.awli-button:focus.state-ready > .ready {display: block;}.awli-button.state-ready > .completed,.awli-button:active.state-ready > .completed,.awli-button:focus.state-ready > .completed {display: none;}.awli-button.state-completed > .loading,.awli-button:active.state-completed > .loading,.awli-button:focus.state-completed > .loading {display: none;}.awli-button.state-completed > .ready,.awli-button:active.state-completed > .ready,.awli-button:focus.state-completed > .ready {display: none;}.awli-button.state-completed > .completed,.awli-button:active.state-completed > .completed,.awli-button:focus.state-completed > .completed {display: block;}.awli-button .icon-checkmark path:first-child,.awli-button:active .icon-checkmark path:first-child,.awli-button:focus .icon-checkmark path:first-child {fill: #fff;}.awli-button .icon-linkedin .icon-li-background,.awli-button:active .icon-linkedin .icon-li-background,.awli-button:focus .icon-linkedin .icon-li-background {fill: currentColor;}.awli-button .icon-linkedin .icon-li-text,.awli-button:active .icon-linkedin .icon-li-text,.awli-button:focus .icon-linkedin .icon-li-text {fill: #0073b1;}.awli-button:hover,.awli-button:active:hover,.awli-button:focus:hover {background: #006299;border-color: #006299;color: #fff;outline: none;}.awli-button:hover.state-loading,.awli-button:active:hover.state-loading,.awli-button:focus:hover.state-loading,.awli-button:hover.state-completed,.awli-button:active:hover.state-completed,.awli-button:focus:hover.state-completed {background: #006299;border-color: #006299;color: #fff;}.awli-button:hover.state-loading .icon-checkmark path:first-child,.awli-button:active:hover.state-loading .icon-checkmark path:first-child,.awli-button:focus:hover.state-loading .icon-checkmark path:first-child,.awli-button:hover.state-completed .icon-checkmark path:first-child,.awli-button:active:hover.state-completed .icon-checkmark path:first-child,.awli-button:focus:hover.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button.state-loading,.awli-button:active.state-loading,.awli-button:focus.state-loading,.awli-button.state-completed,.awli-button:active.state-completed,.awli-button:focus.state-completed {background: #0073b1;border-color: #0073b1;color: #fff;}.awli-button.state-loading .icon-checkmark path:first-child,.awli-button:active.state-loading .icon-checkmark path:first-child,.awli-button:focus.state-loading .icon-checkmark path:first-child,.awli-button.state-completed .icon-checkmark path:first-child,.awli-button:active.state-completed .icon-checkmark path:first-child,.awli-button:focus.state-completed .icon-checkmark path:first-child {fill: #fff;}.awli-button-label {line-height: 1.33;display: block;overflow: hidden;text-align: left;}.awli-disclaimer {color: #969799;font-size: 12px;line-height: 14px;display: inline-block;padding: 10px 0;margin: 0;vertical-align: middle;}.awli-disclaimer a,.awli-disclaimer a:active,.awli-disclaimer a:focus {color: #707173;}.awli-disclaimer a:hover {color: #969799;}.IN-Awli-widget,.IN-widget {display: inline-block;position: absolute;z-index: 0;}.IN-Awli-widget.IN-Awli-widget,.IN-widget.IN-Awli-widget {left: 2px;top: -37px;}.IN-Awli-widget.IN-widget,.IN-widget.IN-widget {left: 4px;top: 7px;}.h-captcha-spacing {width: 304px;height: 78px;}.consent-required:not(:has(div)):after,.consent-required > div:last-child:after {color: #ff794f;content: '✱';display: inline-block;margin-left: 4px;font-size: 9px;position: absolute;}.eeo-light-text {color: #555659;}h5.eeo-paragraph-heading {font-weight: bold;margin-top: 17.5px;}h5.eeo-paragraph-heading + p {margin-top: 0;}hr {border: 1px solid #e3e4e6;}.application .eeo-option-text.application-answer-alternative {margin-bottom: 0;}.eeo-option-description {color: #555659;font-size: 12px;}.eeo-three-col-list {-webkit-column-width: 233.33333333333334px;-moz-column-width: 233.33333333333334px;column-width: 233.33333333333334px;}.eeo-three-col-list > li {margin-left: 30px;}.eeo-more-info-button {display: inline-block;margin-left: 10px;vertical-align: middle;}.eeo-more-info-button > .icon-info > path {fill: #969799;}.eeo-more-info-button:hover > .icon-info > path {fill: #555659;}.eeo-expandable-description > li {margin-bottom: 10px;}li.select2-results__option.select2-results__option--highlighted .posting-option .posting-tags {color: #fff;}.posting-option {display: block;}.posting-option .posting-tags {display: block;line-height: 1em;font-size: 0.6em;color: #939393;}.posting-option .posting-tag {padding-right: 3px;}.posting-option .posting-title {text-align: left;}@-moz-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-webkit-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-o-keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@keyframes fadein {0% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}70% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}100% {opacity: 1;-ms-filter: none;filter: none;}}@-moz-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-webkit-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-o-keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@keyframes fadeout {0% {opacity: 1;-ms-filter: none;filter: none;}80% {opacity: 1;-ms-filter: none;filter: none;}100% {opacity: 0;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";filter: alpha(opacity=0);}}@-moz-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-webkit-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@-o-keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@keyframes loading {0% {-webkit-transform: rotate(0deg);-moz-transform: rotate(0deg);-o-transform: rotate(0deg);-ms-transform: rotate(0deg);transform: rotate(0deg);}100% {-webkit-transform: rotate(360deg);-moz-transform: rotate(360deg);-o-transform: rotate(360deg);-ms-transform: rotate(360deg);transform: rotate(360deg);}}@media screen and (min-width: 800px) {.application .application-label,.eeo-survey .application-label,.application .application-field,.eeo-survey .application-field {display: inline-block;}.application .application-label,.eeo-survey .application-label {width: 210px;}.application .application-label.full-width,.eeo-survey .application-label.full-width {width: 100%;}.application .application-field,.eeo-survey .application-field {margin-left: 15px;width: 489px;}.application .application-field.full-width,.eeo-survey .application-field.full-width {padding-left: 0;width: 100%;}}.list .agency-header {font-size: 30px;}.list .agency-sub-header {color: #808080;}.list .postings-list-logo {max-width: 400px;max-height: 50px;}.list .postings-list-logo,.list .postings-list-title {display: inline-block;position: relative;min-height: 50px;float: left;}.list .postings-list-title {margin: 13px 0px 13px 0px;}.list .postings-list-logo {margin-right: 20px;}.list .filter-by-label {margin-right: 16px;}.list .filter-bar {line-height: 40px;max-width: 100%;}.list .filter-bar > div:last-of-type {margin-right: 0;}.list .filter-button-wrapper-margin-right {margin-right: 16px;}.list .filter-button-wrapper {display: inline-block;max-width: 100%;outline: none;position: relative;}.list .filter-button-wrapper:focus .filter-button {border-color: #0c92f3;}.list .filter-button-wrapper:active .filter-button {border-color: #dcdcdc;}.list .filter-button-wrapper .filter-button {color: #555659;max-width: 100%;overflow: hidden;padding: 5px 15px;padding-right: 41px;position: relative;-o-text-overflow: ellipsis;text-overflow: ellipsis;}.list .filter-button-wrapper .filter-button.has-selected-filter {color: #555659;font-weight: bold;}.list .filter-button-wrapper .filter-button .filter-button-caret {position: absolute;left: auto;left: initial;right: 15px;vertical-align: middle;}.list .filter-button-wrapper .filter-button.filter-button-mlp {padding: 8px 16px;width: 173px;font-size: 12px;text-align: left;}.list .filter-popup {position: absolute;top: 110%;left: -1px;border: 1px solid #dcdcdc;border-radius: 3px;display: none;font-size: 14px;line-height: 1;max-height: 300px;overflow-y: hidden;overflow-y: auto;text-align: left;white-space: nowrap;z-index: 1;}.list .filter-popup::-webkit-scrollbar {width: 10px;}.list .filter-popup::-webkit-scrollbar-track {background-color: #fff;}.list .filter-popup::-webkit-scrollbar-track:hover {background-color: #f9f9f9;}.list .filter-popup::-webkit-scrollbar-thumb {background-color: #d7d7d9;border: 1px solid #fff;}.list .filter-popup::-webkit-scrollbar-thumb:hover {background-color: #b1b1b3;border-color: #f9f9f9;}.list .filter-popup ul {list-style-type: none;}.list .filter-popup > ul {background: #fff;padding: 8px 0;}.list .filter-popup .group-link,.list .filter-popup .category-link {display: block;padding: 8px 32px;position: relative;}.list .filter-popup .group-link:hover,.list .filter-popup .category-link:hover {background: #f9f9f9;}.list .filter-popup .group-link:focus,.list .filter-popup .category-link:focus {background: #f3faff;outline: none;}.list .filter-popup .group-link .selected-filter-checkmark,.list .filter-popup .category-link .selected-filter-checkmark {position: absolute;left: 8px;}.list .filter-popup .group-link .selected-filter-checkmark > path,.list .filter-popup .category-link .selected-filter-checkmark > path {fill: #0c92f3;}.list .filter-popup .group-link {font-size: 16px;font-weight: bold;}.list .filter-popup .group-item {border-top: 1px solid #e3e4e6;padding: 8px 0;}.list .filter-popup .group-item:first-of-type {border-top: none;padding-top: 0;}.list .filter-popup .group-item:last-of-type {padding-bottom: 0;}.list .no-postings-message {margin-top: 80px;text-align: center;}.list .postings-group {margin: 40px 0px;}.list .horizontal-line {margin-left: 0px;}.list .posting {display: inline-block;position: relative;width: 100%;margin: 10px 0;}.list .posting .posting-apply {position: absolute;top: 0px;right: 0px;height: 40px;text-align: right;}.list .posting .posting-apply a {min-width: 100px;}.list .posting .posting-title:hover h5 {color: #579eee;}.list .posting .agency-posting-title h5 {margin-right: 230px;}.list .posting .posting-categories {height: 30px;vertical-align: top;}.list .posting .posting-category {display: inline-block;margin-right: 15px;}.show .section p {white-space: pre-wrap;}.show .posting-header {-webkit-box-sizing: content-box;-moz-box-sizing: content-box;box-sizing: content-box;}.show .posting-header .posting-headline .posting-category {display: inline-block;margin-right: 10px;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-top: 10px;}@media screen and (min-width: 650px) {.show .posting-header .posting-headline {display: table-cell;width: 100%;}.show .posting-header .postings-btn-wrapper {display: table-cell;vertical-align: top;}.show .posting-header .postings-btn-wrapper .postings-btn {margin-left: 30px;}}@media screen and (max-width: 649px) {.show .posting-header {text-align: center;padding-bottom: 40px;}}@media screen and (max-width: 480px) {.show .postings-btn {width: 100%;}}@media print {.postings-btn {display: none !important;}}.page-centered.section.last-section-apply {text-align: center;margin-bottom: 80px;}.page-centered.section.last-section-apply .btn {display: inline-block;}.page-centered.section.last-section-apply .template-btn-submit {margin: 17.5px 0px;}</style></head><body class="list header-compact"><div class="page list"><div class="main-header page-full-width section-wrapper"><div class="main-header-content page-centered narrow-section page-full-width"><a href="https://jobs.lever.co/GoToGroup" class="main-header-logo"><img alt="GoTo Group logo" src="https://lever-client-logos.s3.us-west-2.amazonaws.com/ea3dc26a-36d6-4989-8596-ac871e4a9e82-1682066441676.png"></a></div></div></div><div class="content-wrapper list-page"><div class="content"><div class="section-wrapper page-full-width"><div class="section page-centered"><div class="filter-bar"><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?workplaceType=onsite" rel="nofollow">On-site</a></li><li><a class="category-link" href="?workplaceType=hybrid" rel="nofollow">Hybrid</a></li><li><a class="category-link" href="?workplaceType=remote" rel="nofollow">Remote</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Location: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Location<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?location=Bali" rel="nofollow">Bali</a></li><li><a class="category-link" href="?location=Balikpapan" rel="nofollow">Balikpapan</a></li><li><a class="category-link" href="?location=Bengaluru" rel="nofollow">Bengaluru</a></li><li><a class="category-link" href="?location=Bogor" rel="nofollow">Bogor</a></li><li><a class="category-link" href="?location=Depok" rel="nofollow">Depok</a></li><li><a class="category-link" href="?location=Gurugram" rel="nofollow">Gurugram</a></li><li><a class="category-link" href="?location=Ho%20Chi%20Minh%20City" rel="nofollow">Ho Chi Minh City</a></li><li><a class="category-link" href="?location=Jakarta" rel="nofollow">Jakarta</a></li><li><a class="category-link" href="?location=Makassar" rel="nofollow">Makassar</a></li><li><a class="category-link" href="?location=Semarang" rel="nofollow">Semarang</a></li><li><a class="category-link" href="?location=Singapore" rel="nofollow">Singapore</a></li><li><a class="category-link" href="?location=Tangerang" rel="nofollow">Tangerang</a></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Team: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Team<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li class="group-item"><a class="group-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li class="group-item" role="group" aria-label="FinTech - AML/CFT"><a class="group-link" href="?department=FinTech%20-%20AML%2FCFT" rel="nofollow">FinTech - AML/CFT</a><ul><li><a class="category-link" href="?department=FinTech%20-%20AML%2FCFT&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - CISO"><a class="group-link" href="?department=FinTech%20-%20CISO" rel="nofollow">FinTech - CISO</a><ul><li><a class="category-link" href="?department=FinTech%20-%20CISO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Compliance"><a class="group-link" href="?department=FinTech%20-%20Compliance" rel="nofollow">FinTech - Compliance</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Compliance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Consumer Lending"><a class="group-link" href="?department=FinTech%20-%20Consumer%20Lending" rel="nofollow">FinTech - Consumer Lending</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Lending&amp;team=Lending%20Operations" rel="nofollow">Lending Operations</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Consumer Payments"><a class="group-link" href="?department=FinTech%20-%20Consumer%20Payments" rel="nofollow">FinTech - Consumer Payments</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Consumer%20Experience" rel="nofollow">Consumer Experience</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Money%20Management" rel="nofollow">Money Management</a></li><li><a class="category-link" href="?department=FinTech%20-%20Consumer%20Payments&amp;team=Payment%20Core" rel="nofollow">Payment Core</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Crypto"><a class="group-link" href="?department=FinTech%20-%20Crypto" rel="nofollow">FinTech - Crypto</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Crypto&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Data Products &amp; Infra"><a class="group-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra" rel="nofollow">FinTech - Data Products &amp; Infra</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Data%20Products%20%26%20Infra&amp;team=OneKYC" rel="nofollow">OneKYC</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Finance"><a class="group-link" href="?department=FinTech%20-%20Finance" rel="nofollow">FinTech - Finance</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Finance&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="FinTech - Merchant Services"><a class="group-link" href="?department=FinTech%20-%20Merchant%20Services" rel="nofollow">FinTech - Merchant Services</a><ul><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Merchant%20Lending" rel="nofollow">Merchant Lending</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Offline%20Merchants" rel="nofollow">Offline Merchants</a></li><li><a class="category-link" href="?department=FinTech%20-%20Merchant%20Services&amp;team=Online%20Merchants" rel="nofollow">Online Merchants</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - CIO"><a class="group-link" href="?department=HoldCo%20-%20CIO" rel="nofollow">HoldCo - CIO</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20CIO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - CISO"><a class="group-link" href="?department=HoldCo%20-%20CISO" rel="nofollow">HoldCo - CISO</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20CISO&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - COO Office"><a class="group-link" href="?department=HoldCo%20-%20COO%20Office" rel="nofollow">HoldCo - COO Office</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20COO%20Office&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Corporate Affairs"><a class="group-link" href="?department=HoldCo%20-%20Corporate%20Affairs" rel="nofollow">HoldCo - Corporate Affairs</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Corporate%20Affairs&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=HoldCo%20-%20Corporate%20Affairs&amp;team=Media%20Intelligence" rel="nofollow">Media Intelligence</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Enterprise Risk Management"><a class="group-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management" rel="nofollow">HoldCo - Enterprise Risk Management</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Enterprise%20Risk%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - ESG"><a class="group-link" href="?department=HoldCo%20-%20ESG" rel="nofollow">HoldCo - ESG</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20ESG&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - Finance"><a class="group-link" href="?department=HoldCo%20-%20Finance" rel="nofollow">HoldCo - Finance</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20Finance&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=HoldCo%20-%20Finance&amp;team=Procurement" rel="nofollow">Procurement</a></li></ul></li><li class="group-item" role="group" aria-label="HoldCo - People &amp; Culture"><a class="group-link" href="?department=HoldCo%20-%20People%20%26%20Culture" rel="nofollow">HoldCo - People &amp; Culture</a><ul><li><a class="category-link" href="?department=HoldCo%20-%20People%20%26%20Culture&amp;team=HR%20Information%20Systems" rel="nofollow">HR Information Systems</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Ads"><a class="group-link" href="?department=ODS%20-%20Ads" rel="nofollow">ODS - Ads</a><ul><li><a class="category-link" href="?department=ODS%20-%20Ads&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Consumer Platform"><a class="group-link" href="?department=ODS%20-%20Consumer%20Platform" rel="nofollow">ODS - Consumer Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Consumer%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Data Platform"><a class="group-link" href="?department=ODS%20-%20Data%20Platform" rel="nofollow">ODS - Data Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Data%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Engineering Platform"><a class="group-link" href="?department=ODS%20-%20Engineering%20Platform" rel="nofollow">ODS - Engineering Platform</a><ul><li><a class="category-link" href="?department=ODS%20-%20Engineering%20Platform&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Food"><a class="group-link" href="?department=ODS%20-%20Food" rel="nofollow">ODS - Food</a><ul><li><a class="category-link" href="?department=ODS%20-%20Food&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Groceries"><a class="group-link" href="?department=ODS%20-%20Groceries" rel="nofollow">ODS - Groceries</a><ul><li><a class="category-link" href="?department=ODS%20-%20Groceries&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Logistics"><a class="group-link" href="?department=ODS%20-%20Logistics" rel="nofollow">ODS - Logistics</a><ul><li><a class="category-link" href="?department=ODS%20-%20Logistics&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Marketplace"><a class="group-link" href="?department=ODS%20-%20Marketplace" rel="nofollow">ODS - Marketplace</a><ul><li><a class="category-link" href="?department=ODS%20-%20Marketplace&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Platform Mobility, Care &amp; Comms"><a class="group-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms" rel="nofollow">ODS - Platform Mobility, Care &amp; Comms</a><ul><li><a class="category-link" href="?department=ODS%20-%20Platform%20Mobility%2C%20Care%20%26%20Comms&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Public Policy &amp; Government Relations"><a class="group-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations" rel="nofollow">ODS - Public Policy &amp; Government Relations</a><ul><li><a class="category-link" href="?department=ODS%20-%20Public%20Policy%20%26%20Government%20Relations&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Regions"><a class="group-link" href="?department=ODS%20-%20Regions" rel="nofollow">ODS - Regions</a><ul><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Central%20West%20Java%20Regions" rel="nofollow">Central West Java Regions</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=East%20Java%2C%20Bali%2C%20Nusra%20Regions" rel="nofollow">East Java, Bali, Nusra Regions</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Emerging%20Market" rel="nofollow">Emerging Market</a></li><li><a class="category-link" href="?department=ODS%20-%20Regions&amp;team=Jabodetabek%20Regions" rel="nofollow">Jabodetabek Regions</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Sales"><a class="group-link" href="?department=ODS%20-%20Sales" rel="nofollow">ODS - Sales</a><ul><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=-" rel="nofollow">-</a></li><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=Sales%20Excellence" rel="nofollow">Sales Excellence</a></li><li><a class="category-link" href="?department=ODS%20-%20Sales&amp;team=Sales%20Strategy" rel="nofollow">Sales Strategy</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Customer Relationship Management"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management" rel="nofollow">ODS - Shared Service, Customer Relationship Management</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Customer%20Relationship%20Management&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Marketing"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing" rel="nofollow">ODS - Shared Service, Marketing</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Marketing&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Shared Service, Technology"><a class="group-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology" rel="nofollow">ODS - Shared Service, Technology</a><ul><li><a class="category-link" href="?department=ODS%20-%20Shared%20Service%2C%20Technology&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport"><a class="group-link" href="?department=ODS%20-%20Transport" rel="nofollow">ODS - Transport</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport&amp;team=-" rel="nofollow">-</a></li></ul></li><li class="group-item" role="group" aria-label="ODS - Transport &amp; Mobility"><a class="group-link" href="?department=ODS%20-%20Transport%20%26%20Mobility" rel="nofollow">ODS - Transport &amp; Mobility</a><ul><li><a class="category-link" href="?department=ODS%20-%20Transport%20%26%20Mobility&amp;team=-" rel="nofollow">-</a></li></ul></li></ul></div></div><div role="button" class="filter-button-wrapper filter-button-wrapper-margin-right" tabindex="0" aria-label="Filter by Work type: All" aria-haspopup="true" aria-expanded="false"><div class="filter-button filter-button-mlp">Work type<svg class="filter-button-caret icon icon-caret-down" width="16px" height="16px" viewBox="0 0 16 16"><path d="M7.93207 10.767L12.8077 5.54806L12.2857 5.06044L7.93207 9.70631L3.52195 5L3 5.48762L7.93207 10.767Z"></path></svg></div><div class="filter-popup" aria-hidden="false"><ul><li><a class="category-link selected" href="?" rel="nofollow"><svg class="selected-filter-checkmark icon icon-check" width="16px" height="16px" viewBox="0 0 16 16"><path d="M6.2,14.4L0,8.2l2.5-2.5l3.5,3.5c0.1,0.1,0.2,0.1,0.2,0L13.5,2L16,4.5L6.2,14.4z"></path></svg>All</a></li><li><a class="category-link" href="?commitment=Direct%20Contract" rel="nofollow">Direct Contract</a></li><li><a class="category-link" href="?commitment=Internship" rel="nofollow">Internship</a></li><li><a class="category-link" href="?commitment=Permanent" rel="nofollow">Permanent</a></li><li><a class="category-link" href="?commitment=" rel="nofollow">Uncategorized</a></li></ul></div></div><noscript><style type="text/css">.filter-button-wrapper:focus {outline: none;}.filter-button-wrapper .filter-popup {top: 100%;}.filter-button-wrapper:focus .filter-popup,.filter-button-wrapper:hover .filter-popup,.filter-button-wrapper:active .filter-popup {display: block;}</style></noscript></div><div class="postings-wrapper"><div class="postings-group"><div class="large-category-header">FinTech - AML/CFT</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f8ec8194-1eb5-4bdb-8419-a57a4966b1c5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5"><h5 data-qa="posting-name">Merchants AML/CFT Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - CISO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="36caef5f-7a1c-4326-80b4-8c146060ac70"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70"><h5 data-qa="posting-name">IT GRC Senior Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Compliance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a9daeacc-5dda-4735-ad7b-db35eb7593a6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6"><h5 data-qa="posting-name">FinServ Compliance Officer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="90d1d8b9-75fb-4211-8d69-99412932f5ba"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba"><h5 data-qa="posting-name">Payments Compliance PPGR Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Consumer Lending</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a3543985-6d2c-45cf-84f7-312ec7efed36"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36"><h5 data-qa="posting-name">Full Stack Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9bc8bd8a-cadc-4942-81c4-193773a294df"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df"><h5 data-qa="posting-name">Growth Analyst - GoPay Later</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6dc20c4e-4d40-4f57-a138-4776013e454e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e"><h5 data-qa="posting-name">Head of Operation - Consumer Lending - #10162</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c9452ba2-cbb3-4ea5-83f7-79e765a67e58"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58"><h5 data-qa="posting-name">Lead Internal Auditor</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0"><h5 data-qa="posting-name">Lead MLOps Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="44117b68-3ece-40ac-91c1-920caadfe5dd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd"><h5 data-qa="posting-name">Principal Data Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="92f4b266-849a-42f2-b7e0-859360a003d8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8"><h5 data-qa="posting-name">Program Manager, Consumer Lending - #10310</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="5611e062-e094-4da3-ab1c-75c85cf62194"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194"><h5 data-qa="posting-name">Risk Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b"><h5 data-qa="posting-name">Senior Data Analyst (Analytics Engineer)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="472ae629-87cb-4f8c-bb69-eae35cf3751e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e"><h5 data-qa="posting-name">Senior SDET - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d3b7122b-692b-4815-8aa9-f1d0259bccd5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5"><h5 data-qa="posting-name">Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac"><h5 data-qa="posting-name">Senior Software Engineer (Backend) - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7"><h5 data-qa="posting-name">Site Reliability Engineer - Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="88358de8-e37b-4bd6-9afe-359eea3128b9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9"><h5 data-qa="posting-name">Software Engineer (Full Stack) - BNPL</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="afb5bc40-aa4f-4837-a2d9-7d38eade2599"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599"><h5 data-qa="posting-name">Strategy Senior Manager, Consumer Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="17408b81-f5a0-4f15-afae-cc04ed7e43b6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6"><h5 data-qa="posting-name">Underwriting and Credit Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Lending Operations</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="0ae5053b-3c5f-432a-9b69-b4cdefb01b79"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79"><h5 data-qa="posting-name">Operation Business Intelligence Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Consumer Payments</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="325ee617-30f3-41c1-a022-6577bd82faf0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0"><h5 data-qa="posting-name">Business Analyst - GoPay</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9a8977f6-ea32-40e0-bb09-d3330c40d056"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056"><h5 data-qa="posting-name">Business Operations Analyst (Trust and Safety) - GoPay - #10311</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da1197ac-dfbc-4ad6-b215-2f2cd4939a0d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d"><h5 data-qa="posting-name">Junior UX Writer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="153e42ca-cf5b-4f43-b09e-58eabda1e5fa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa"><h5 data-qa="posting-name">Senior SDET - Consumer Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Consumer Experience</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="5f86f9c4-80bc-437f-b09c-b61fd85c27eb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb"><h5 data-qa="posting-name">Growth Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="0169bd4d-f352-4162-8e8e-2c09df5b8db4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4"><h5 data-qa="posting-name">SDET - Growth</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Money Management</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8906c3d0-c77f-4a0a-8f25-8b738515ede3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3"><h5 data-qa="posting-name">QA Engineer - Insurance</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bf41d2c6-91b0-4c83-a145-dfcb3ee24b62"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62"><h5 data-qa="posting-name">Savings Growth Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="389c0346-14e0-40e5-85c3-48d830db73b4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4"><h5 data-qa="posting-name">Senior Software Engineer (iOS) - Money Management</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="75c0d634-b28a-4f10-8f5a-efacb32b6444"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444"><h5 data-qa="posting-name">Sr. Software Engineer (Android) - Insurance</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Payment Core</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="78d59624-b02e-4370-b23b-25677dfb1b20"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20"><h5 data-qa="posting-name">Senior SDET - Consumer Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="076bd021-0157-42a4-89fd-51d9f236e490"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490"><h5 data-qa="posting-name">Senior SDET - Payment Widget &amp; Vendor Gateway</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="96562e50-0bf7-4a14-a910-4ef63f16d451"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451"><h5 data-qa="posting-name">Software Engineer - Android (Consumer Payments)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4439eb62-6f08-444b-946d-1dff07d7d0d3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3"><h5 data-qa="posting-name">Software Engineer - iOS ( Consumer Payments)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Crypto</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="08aa1472-d91f-4c5d-b5e0-e88163943bcd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd"><h5 data-qa="posting-name">Security and System Infra Manager (CISSP) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="fda395d6-457d-4a03-aaa1-33d513c3960b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b"><h5 data-qa="posting-name">Senior Software Engineer (Android) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="769b7391-e6fd-4923-9a92-e060f14e451d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d"><h5 data-qa="posting-name">Senior Software Engineer (Back End) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bcd00ee0-2fb3-43c1-8401-ef184283ccc8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8"><h5 data-qa="posting-name">Senior Software Engineer (Front End) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e6c36118-5d4e-444b-922c-68e03c2ab82e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e"><h5 data-qa="posting-name">Senior Software Engineer (iOS) - Crypto</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Data Products &amp; Infra</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="816f2d4c-5ff6-4e83-8697-9c25df599409"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409"><h5 data-qa="posting-name">Data Scientist Intern</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="0197001e-f39c-4d55-b6b9-1cf247bd17b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0"><h5 data-qa="posting-name">Principal Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="60d37414-287e-4552-a0d0-accf1737d0ce"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce"><h5 data-qa="posting-name">Risk Analyst - Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a61cda6c-82fd-4daf-aabf-3db91e01684f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f"><h5 data-qa="posting-name">Risk Manager - Payments</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b"><h5 data-qa="posting-name">Senior Data Engineer - Data Streaming</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="a539cdc1-109f-48e8-9b24-1a831b735f01"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01"><h5 data-qa="posting-name">Senior Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="10dbc666-80f8-4250-85ee-59fa92d056aa"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa"><h5 data-qa="posting-name">Senior Software Engineer (Data Warehouse)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="449dd201-2d4d-47a0-9cd4-c7ddec91c88e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e"><h5 data-qa="posting-name">Senior Software Engineer (Real-Time Data Streaming)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">OneKYC</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="c98e554f-20cd-4d37-80b7-46794ef7bedb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb"><h5 data-qa="posting-name">Ops and Project Manager - OneKYC</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="22a1f73e-1fed-464e-a66c-72139d289c14"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14"><h5 data-qa="posting-name">Project Manager - OneKYC</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="60283bc5-9f60-400a-8289-bcbe332fbc09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09"><h5 data-qa="posting-name">Financial Controller Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">FinTech - Merchant Services</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="761415aa-89b7-4ffb-a19b-2b91ac4243b4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4"><h5 data-qa="posting-name">Growth Lead (Merchant Lending)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="70493d8a-7d7f-4660-b1ed-c792d0d765be"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be"><h5 data-qa="posting-name">Head of Sales - Midtrans - #9618</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="3f4f687f-8599-4d5c-96d5-8af234c3b09d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d"><h5 data-qa="posting-name">Onboarding &amp; Support Business Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="fc7c3413-6c4f-42bd-a048-70387bd490a4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4"><h5 data-qa="posting-name">Process Improvement Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9"><h5 data-qa="posting-name">Sales Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Merchant Lending</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="dab778da-b4eb-4e7e-bc8e-997af7210d52"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52"><h5 data-qa="posting-name">Software Engineer (Back End) - Merchant Lending</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Offline Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ad8bd932-3494-4181-bd93-282665dce81d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d"><h5 data-qa="posting-name">Learning &amp; Development Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44"><h5 data-qa="posting-name">Product Design Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="50c8a826-2076-40a3-a829-b96b29c9647f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f"><h5 data-qa="posting-name">Senior Product Marketing Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Online Merchants</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="83c662d2-4a1e-40ca-a2d3-daf2a1b102b8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8"><h5 data-qa="posting-name">Product Analyst Intern - Online Merchants</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="afd9e752-82f0-4b4f-a4ef-5d86dcce1063"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063"><h5 data-qa="posting-name">Senior Sales Manager - Midtrans</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1a190954-9482-4953-a750-f2ae33a50003"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003"><h5 data-qa="posting-name">Software Engineer Intern - Online Merchants</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - CIO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4cb00240-117e-4ace-a959-fc567e447d5f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f"><h5 data-qa="posting-name">IT Finance Project Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="099498bc-c171-4505-97d7-3a432d302e14"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14"><h5 data-qa="posting-name">Senior SAP Technical</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - CISO</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="178ba514-705f-4f0b-9e48-fe917c47a95b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b"><h5 data-qa="posting-name">Enterprise Information Security Engineer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9a7a6e83-9532-48a6-b1b1-b7a1350b4f12"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12"><h5 data-qa="posting-name">Security Engineering Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="767d8980-5402-488d-b62c-222c0b4a0bfc"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc"><h5 data-qa="posting-name">Senior Cyber Threat Intelligence Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - COO Office</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="2242125a-7155-4353-bc79-473d237d6808"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808"><h5 data-qa="posting-name">Business Intelligence Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="73e71b86-d53f-4841-92ec-4bd09a0ef479"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479"><h5 data-qa="posting-name">Data Engineer Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="36d71dff-c9ac-44b8-b870-f74d941bd7d3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3"><h5 data-qa="posting-name">Data Engineer Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6d8ebb73-2348-423d-847e-b8a8408ac1ed"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed"><h5 data-qa="posting-name">Senior Data Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Corporate Affairs</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="fc5f2c90-038e-4c53-9971-2ae72f680c03"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03"><h5 data-qa="posting-name">International &amp; Singapore Communications Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Media Intelligence</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a3de3e96-fc51-46e4-bcd4-f012f0d03bdb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb"><h5 data-qa="posting-name">Media Intelligence Intern</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Internship</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Enterprise Risk Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703"><h5 data-qa="posting-name">Head of Business Continuity Management</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="9c0a73a5-09ce-4b06-8527-9415ef3d393c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c"><h5 data-qa="posting-name">Internal Audit Senior Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - ESG</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="1a303596-73f9-4d05-85f9-73cd361f03ef"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef"><h5 data-qa="posting-name">Sustainability Senior Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - Finance</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="56966262-038f-497f-84c1-f360a9440c55"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55"><h5 data-qa="posting-name">Assistant Tax Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Procurement</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274"><h5 data-qa="posting-name">Procurement Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">HoldCo - People &amp; Culture</div><div class="posting-category-title large-category-label">HR Information Systems</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8fe35112-8410-4cf3-9a50-4c7287e95b57"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57"><h5 data-qa="posting-name">People Systems Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta / Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Ads</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="94f85d13-6fe6-43a8-96c8-4898ab75d908"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908"><h5 data-qa="posting-name">Ads Ops Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="eaab5bee-084d-4cdc-bd08-63230251009c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c"><h5 data-qa="posting-name">Supply Strategy Data Analyst [Ads]</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Consumer Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="ab96f280-f1d6-4ff7-bbe8-198ee4168bb4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4"><h5 data-qa="posting-name">Market Intelligence (Data Engineer)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="976d0171-5a06-43e2-9ec6-e0b45345c6fd"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd"><h5 data-qa="posting-name">Senior Data Scientist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="86673189-b5e2-4ace-b1a3-5ab20f14d84d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d"><h5 data-qa="posting-name">Senior Data Scientist (India)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="cd554abc-dc06-4177-be50-ccbc638fd6d9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9"><h5 data-qa="posting-name">Software Engineer - Customer Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Data Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="e6583aa0-7097-4e6f-9f91-7f24d5441156"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156"><h5 data-qa="posting-name">Senior Product Manager, Data Science Platform and Data Products</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta / Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="d8170197-90ca-4f87-a48d-d1a3175538ce"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce"><h5 data-qa="posting-name">Senior Software Engineer - Data Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Engineering Platform</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="dfe98505-36d8-4467-aa36-df8599ab69d8"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8"><h5 data-qa="posting-name">Engineering Manager - Data Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="f7107250-7aa4-487c-8821-8948dfb0fbc3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3"><h5 data-qa="posting-name">Frontend Engineer - Web Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e"><h5 data-qa="posting-name">Fullstack Engineer - Engineering Platforms</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="a593bf17-baf2-479e-8154-c69d6a7d4f09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09"><h5 data-qa="posting-name">Lead Software Engineer - Engineering Platforms</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a"><h5 data-qa="posting-name">Lead Software Engineer - Observability</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="6f2d563a-182c-4c23-8c72-9d2a4f563ed9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9"><h5 data-qa="posting-name">Principal Engineer - Cloud Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru / Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="7c3c43e3-8b8d-48a4-a590-7754207b2d1b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b"><h5 data-qa="posting-name">Principal Software Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69"><h5 data-qa="posting-name">Senior Data Warehouse Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2b430ba4-210e-4db6-a63e-c11459a0304f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f"><h5 data-qa="posting-name">Senior Data Warehouse Engineer - India</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb"><h5 data-qa="posting-name">Senior Database Administrator Engineer - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="28fe323b-ed5f-482b-b71d-ed60662bed8b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b"><h5 data-qa="posting-name">Senior DevOps Engineer - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Gurugram</span></div></a></div><div class="posting" data-qa-posting-id="68f907a3-329f-411b-af2d-a66b38243919"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919"><h5 data-qa="posting-name">Senior Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8afd4278-a5a8-43f2-8718-2986433f2ddb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb"><h5 data-qa="posting-name">Senior Technical Program Manager - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b"><h5 data-qa="posting-name">Software Engineer - Android</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3"><h5 data-qa="posting-name">Technical Program Manager - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Food</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="657d7112-420a-4e42-8bfd-1b790fc05155"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155"><h5 data-qa="posting-name">#10357 Senior Software Engineer - Go-food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e"><h5 data-qa="posting-name">Growth Planning &amp; Operation - GoFood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242"><h5 data-qa="posting-name">Growth Strategy Manager - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="2d3aae20-ff7e-4afb-8164-a351661c1680"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680"><h5 data-qa="posting-name">Lead Software Engineer (IC) - Go-Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="e407433b-435a-4607-89bd-5faf51cf622e"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e"><h5 data-qa="posting-name">Product Designer - Food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba"><h5 data-qa="posting-name">Product Manager - Growth</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="da8d4a37-f5a4-4436-8743-58c787781285"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285"><h5 data-qa="posting-name">Senior Growth Manager - Food &amp; Ads</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="57bb5e7f-9ea0-462f-ac36-5717b49d0380"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380"><h5 data-qa="posting-name">Senior Software Engineer - Go-food</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="930cfb6b-99e3-4334-bc10-3fac18f8eff0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0"><h5 data-qa="posting-name">Software Engineer (Android) - Gofood</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Groceries</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="87b4d0e4-219e-4ba7-9433-27220623ab69"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69"><h5 data-qa="posting-name">#10358 Software Engineer - Backend (Groceries)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="03e3c5dd-2c14-4737-820e-f32b6cccf632"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632"><h5 data-qa="posting-name">Operations Manager - GoMart</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="49388333-1938-4c06-b453-911eee08c53f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f"><h5 data-qa="posting-name">Pricing &amp; Supply Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663"><h5 data-qa="posting-name">User Growth Lead</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Logistics</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f53cae40-f605-4215-9a82-b48c5db508b5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5"><h5 data-qa="posting-name">#10010 Senior Backend Engineer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="ce351965-e2f9-4f8f-8cad-38fb4cd045e9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9"><h5 data-qa="posting-name">#10279 Senior Android Developer (Logistic)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958"><h5 data-qa="posting-name">#10359 Software Engineer - Backend</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="180b3e9e-cfb9-471d-8c30-410aef031535"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535"><h5 data-qa="posting-name">Software Engineer  - Logistic</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Marketplace</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8d7ae844-168c-4e78-843a-94aceb7b1a66"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66"><h5 data-qa="posting-name">Senior Software Engineer  - Marketplace</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Platform Mobility, Care &amp; Comms</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09"><h5 data-qa="posting-name">Product Manager - Logistic</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="34f6146a-c482-407c-a31c-72ac9bb90a7c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c"><h5 data-qa="posting-name">Senior Data Scientist - Marketplace (Singapore)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Public Policy &amp; Government Relations</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5"><h5 data-qa="posting-name">Manager of Food &amp; Groceries Regulatory</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="bf9ad9be-9cca-41e0-9c6d-a6b66e91726b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b"><h5 data-qa="posting-name">Transport and Mobility PPGR Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Regions</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb"><h5 data-qa="posting-name">Area Operations Manager - Bekasi</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c"><h5 data-qa="posting-name">Area Operations Manager (Bogor Depok)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Depok / Bogor</span></div></a></div><div class="posting" data-qa-posting-id="8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2"><h5 data-qa="posting-name">Area Operations Staff</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="719f7a78-460a-4496-9298-ca57b835b120"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120"><h5 data-qa="posting-name">Operation Support Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="4ba1eea8-feed-4843-be2e-93a21f0eadb1"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1"><h5 data-qa="posting-name">Region Analytics Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div><div class="posting" data-qa-posting-id="3377f50a-d56f-42e0-acc5-b69d405a37a9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9"><h5 data-qa="posting-name">Senior/Partnership Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Ho Chi Minh City</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Central West Java Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f1bdce17-4ab5-49ab-9dbc-6d96a5619846"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846"><h5 data-qa="posting-name">Area CE Associate - Semarang - #10227</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Semarang</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">East Java, Bali, Nusra Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="73172a46-5486-4860-a256-8e17225c4a47"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47"><h5 data-qa="posting-name">Account Executive (Bali)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Bali</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Emerging Market</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="95ee9a06-a46d-43a2-a8e7-003de776404d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d"><h5 data-qa="posting-name">Area Operations Supervisor - Balikpapan</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Balikpapan</span></div></a></div><div class="posting" data-qa-posting-id="20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450"><h5 data-qa="posting-name">Area Sales Support Supervisor (Sulampa)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Makassar</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Jabodetabek Regions</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="94efd0c8-e79b-41e1-aa37-a7a4c08c108f"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f"><h5 data-qa="posting-name">Account Executive (Tangerang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div><div class="posting" data-qa-posting-id="885b2af9-c94a-4010-b0c4-c6ea7812039b"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b"><h5 data-qa="posting-name">Account Executive (Tangerang)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Direct Contract</span><span href="#" class="sort-by-location posting-category small-category-label location">Tangerang</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Sales</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="a007af4b-690d-4487-874d-f04ce3f62ce0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0"><h5 data-qa="posting-name">Unmanaged Merchant Engagement Senior Associate - #10326</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Sales Excellence</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="f39be622-e287-41df-bcb2-7389478a1be4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4"><h5 data-qa="posting-name">Sales Support Senior Associate, Enterprise</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="posting-category-title large-category-label">Sales Strategy</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6"><h5 data-qa="posting-name">Head of Sales Strategy - #10056</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Customer Relationship Management</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="0489939a-c571-4d5f-adaa-95ceac8912c5"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5"><h5 data-qa="posting-name">Region Operations Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66"><h5 data-qa="posting-name">Strategic Planner - Creative Labs - #10088</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Marketing</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="7d1c915f-ac53-4a2c-887a-41bbbda48a26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26"><h5 data-qa="posting-name">Graphic Designer</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3"><h5 data-qa="posting-name">Social Media Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Shared Service, Technology</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="4a126665-42d6-4a36-82a5-089dca789f41"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41"><h5 data-qa="posting-name">Lead Software Engineer - Data Science Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="426f18b4-739e-4da0-a74b-446c349c0a31"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31"><h5 data-qa="posting-name">Principal Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="376aefd9-6d6c-4e57-8040-a3b0dd416d26"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9"><h5 data-qa="posting-name">SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4"><h5 data-qa="posting-name">Senior SDET - Automation Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="331177df-4294-4bc1-93a4-6459ff18ef97"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97"><h5 data-qa="posting-name">Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="e2bbb29c-85ef-4db2-9ea7-93af9101b634"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634"><h5 data-qa="posting-name">Sr. Software Engineer (iOS) - Engineering Platform</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru / Jakarta</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="d93a7524-8ab9-4499-9f04-0876fcafa529"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529"><h5 data-qa="posting-name">Data Operations Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="5d07cd21-8826-4de7-9ad4-15909a0c5c37"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37"><h5 data-qa="posting-name">Digital Marketing Specialist</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="eb38692a-8133-4cd2-a793-f5d75ee8841a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a"><h5 data-qa="posting-name">Driver Care Lead, Hub Operations</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="c48698b4-3bff-4e56-b250-cadf67700c6d"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d"><h5 data-qa="posting-name">Fleet Account Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c838dc08-24e8-417c-9d70-a617bc58e200"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200"><h5 data-qa="posting-name">Head of Engineering - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="f1d481f6-4e2d-401b-b310-fca641ab29d4"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4"><h5 data-qa="posting-name">Lead - iOS (Transport)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="9e0d8fd7-d416-49ee-8c0a-fcad22c923b7"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7"><h5 data-qa="posting-name">Lead Software Engineer - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="967cfe0a-0243-4a2d-8813-038c355e43c3"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3"><h5 data-qa="posting-name">Marketing Planning Manager</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="6f3368c9-6e84-489c-add3-4ad1fd4b9519"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519"><h5 data-qa="posting-name">Operations Analyst, Data Operations (Trust &amp; Safety)</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Singapore</span></div></a></div><div class="posting" data-qa-posting-id="0911a6fe-475a-498f-bf48-7d492e3d04d2"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2"><h5 data-qa="posting-name">Pricing &amp; Supply Senior Associate</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="20554643-fae8-4082-8797-7d5fd44db8b0"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0"><h5 data-qa="posting-name">Project Manager - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb"><h5 data-qa="posting-name">Risk Analyst</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="53c0b8a9-1a83-4c34-9a59-b5170ce54193"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193"><h5 data-qa="posting-name">Senior Software Engineer - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="c0e92e19-ce60-4cfc-a58b-553f17452483"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483"><h5 data-qa="posting-name">Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div><div class="posting" data-qa-posting-id="89a62415-b145-4593-ac20-b82ec0ccfacb"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb"><h5 data-qa="posting-name">Software Engineer (iOS) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div><div class="posting" data-qa-posting-id="22ac4805-bcbe-4698-9e51-cb25754ac244"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244"><h5 data-qa="posting-name">Sr. Software Engineer (Backend) - Transport</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Bengaluru</span></div></a></div></div><div class="postings-group"><div class="large-category-header">ODS - Transport &amp; Mobility</div><div class="posting-category-title large-category-label">-</div><div class="horizontal-line"></div><div class="posting" data-qa-posting-id="8bf17375-6318-400f-8216-4a132071777a"><div class="posting-apply" data-qa="btn-apply"><a href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a" class="posting-btn-submit template-btn-submit hex-color">Apply</a></div><a class="posting-title" href="https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a"><h5 data-qa="posting-name">Lead Product Manager, GoCorp</h5><div class="posting-categories"><span href="#" class="display-inline-block small-category-label workplaceTypes">On-site — </span><span href="#" class="sort-by-commitment posting-category small-category-label commitment">Permanent</span><span href="#" class="sort-by-location posting-category small-category-label location">Jakarta</span></div></a></div></div></div></div></div></div></div><div class="main-footer page-full-width"><div class="main-footer-text page-centered"><p><a href="https://www.gotocompany.com/">GoTo Group Home Page</a></p><a href="https://www.lever.co/job-seeker-support/" class="image-link"><span>Jobs powered by </span><img alt="Lever logo" src="/img/lever-logo-full.svg"></a></div></div><script src="/js/bug-snag.js" data-apikey="6a247c6ff13012d02fde17377f0b857b" data-appversion="0.0.1721278246" data-endpoint="https://bugs.lever.co/js" data-releasestage="production"></script><script>var gaCode = "UA-129682534-1";</script><script>var gaAllowLinker = false;</script><script async src="https://www.googletagmanager.com/gtag/js?id=UA-129682534-1"></script><script>if (gaCode.startsWith('UA')) {window.initializeGoogleAnalytics = function() {(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,'script','//www.google-analytics.com/analytics.js','ga');ga('create', gaCode, {name: "customer",allowLinker: gaAllowLinker,});ga('customer.send', 'pageview');}} else {window.initializeGoogleAnalytics = function() {window.dataLayer = window.dataLayer || [];function gtag(){dataLayer.push(arguments);}gtag('js', new Date());gtag('config', gaCode);if (gaAllowLinker) {gtag('set', 'linker', 'lever.co');}}}</script><script type="text/javascript">/*We only want to not initialize Google Analytics and Segment on load if the following is true:- `gdpr` is enabled for the account- the account has the `cookieBanner` enabled- the account has the `optIn` cookieBanner typeThis is the only case where an applicant has to explicitly opt-in to the cookie consent before we can load GA/Segment*//* 2022-03-08: Disabling segment tracking due to an explosion in MAU after removing identify call */window.initializeGoogleAnalytics();window.hasInitializedAnalytics = true;</script></body></html><script src="/js/jquery-3.6.1.min.js"></script><script src="/js/list.js"></script>
+  recorded_at: Tue, 30 Jul 2024 16:28:26 GMT
 - request:
     method: get
     uri: https://api.lever.co/v0/postings/GoToGroup/?mode=json
@@ -103,11 +103,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:45 GMT
+      - Tue, 30 Jul 2024 16:28:27 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
-      - '1432517'
+      - '1477609'
       Connection:
       - keep-alive
       Strict-Transport-Security:
@@ -117,17 +117,17 @@ http_interactions:
       X-Xss-Protection:
       - 1; mode=block
       Etag:
-      - W/"15dbc5-TMDXewzNtQhkDif5BtDZT8K87dM"
+      - W/"168be9-PtUkFuKXj/26omgKM7XfE6VxSmE"
       X-Stream-Path:
       - dapi
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        [{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721638994130,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","id":"f53cae40-f605-4215-9a82-b48c5db508b5","lists":[{"text":"What you will do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance.</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Actively mentor SE/ASEs&nbsp; in the teamTranslate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environmentsImprove engineering standards, tooling and processes</li>"},{"text":"What you will need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applicationsHave expertise in at least one of Go or JavaIn-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etcExcellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"#10010 Senior Backend Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5","applyUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5/apply"},{"additionalPlain":"The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.\nThe Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.\nWe, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.\n","additional":"<div><span style=\"font-size: 10pt\">The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 10pt\">The Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.</span></div><div><span style=\"font-size: 10pt\">We, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721640901865,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","id":"ce351965-e2f9-4f8f-8cad-38fb4cd045e9","lists":[{"text":"What you will do","content":"<li>Independently responsible for the entire lifecycle of high-complexity Android projects or features including software design, development, and deployment within their team</li><li>Planning &amp; timely delivery of work within their teamImproving code structure and architecture in service of testability and maintainability</li><li>Writing, co-writing, and reviewing design documentation</li><li>Leading new language/framework POCsParticipating in the design review process, seeking and providing constructive criticism</li><li>Tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Ensuring that their team has strong sets of documentation and journals of how their design and architecture evolve over time</li><li>Ensuring predictability, quality &amp; throughput of their team's delivery</li><li>Prioritizing and valuing work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalating challenges that are outside their control but affect the team's delivery</li><li>Prioritizing work based on understanding the trade-off between quality, tech-debt, and delivery</li><li>Leading effort to work with other teams to solve problems affecting the delivery of their team</li><li>Participating in prioritization of cross teams initiatives &amp; leading those within their own team</li><li>Splitting complex engineering task into smaller components which can be developed by junior engineers in the team</li><li>Mentoring other engineers on an individual basis</li><li>Participating in the hiring process (by meeting candidates, and attending recruiting events)</li><li>Conducting engineering interviews</li>"},{"text":"What you will need","content":"<li>Should have at least 4 years of experience with Android developmentProficient in Kotlin programming, Java, and Android APIs.</li><li>Strong knowledge of Android Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standards across the teamWorking experience with popular libraries for networking, async, image loading, etc.</li><li>Well-versed with Agile methodologies, TDD, and Test Engineering &amp; Automation.</li><li><b>Bonus points if:&nbsp;</b>Have experience in Running A/B or multi-variant experiments for features that you built.</li>"}],"text":"#10279 Senior Android Developer (Logistic)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9","applyUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898011592,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"657d7112-420a-4e42-8bfd-1b790fc05155","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"#10357 Senior Software Engineer - Go-food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155","applyUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721901545426,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"87b4d0e4-219e-4ba7-9433-27220623ab69","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10358 Software Engineer - Backend (Groceries)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69","applyUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898703682,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10359 Software Engineer - Backend","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","applyUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</div>","categories":{"department":"ODS - Regions","location":"Bali","team":"East Java, Bali, Nusra Regions","allLocations":["Bali"]},"createdAt":1720778770433,"descriptionPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"73172a46-5486-4860-a256-8e17225c4a47","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transaction</li><li>Create regular report to what's happen in their respective areas toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Fresh Graduate are welcome to Apply&nbsp;</li><li>2 years relevant experience with preferable industries: top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region will be a plus</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Bali)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47","applyUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721704703939,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"885b2af9-c94a-4010-b0c4-c6ea7812039b","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b","applyUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721037961422,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"94efd0c8-e79b-41e1-aa37-a7a4c08c108f","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f","applyUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f/apply"},{"additionalPlain":"About the team\n\nOur GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n","additional":"<div><b>About the team</b></div><div><br></div><div>Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</div><div><br></div><div>Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</div>","categories":{"department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721623842937,"descriptionPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","id":"94f85d13-6fe6-43a8-96c8-4898ab75d908","lists":[{"text":"What Will You Do","content":"<li>Executing campaign creation of our merchants through our inhouse portal and assist in troubleshooting to our product managers and engineers&nbsp;</li><li>Proactively improve the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Learn to introduce beneficial business changes through well-written document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Support and coordinate with multiple stakeholders to ensure seamless workflow, update relevant changes and address any operational issues</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resources</li>"},{"text":"What Will You Need","content":"<li>Minimum 1 year of working experience&nbsp;</li><li>End to end the problem-solving mindset that can work well with stakeholders&nbsp;</li><li>Basic data analytics capability, having capability in SQL is a plus</li><li>Experience in Growth, Product Management, and Data team is a plus</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders&nbsp;</li><li>Open to acquiring new skills and taking on diverse projects</li>"}],"text":"Ads Ops Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","descriptionBodyPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908","applyUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908/apply"},{"additionalPlain":"About The Team\nArea CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales & analytics team) in the designated Areas.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Area CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales &amp; analytics team) in the designated Areas.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Semarang","team":"Central West Java Regions","allLocations":["Semarang"]},"createdAt":1720592465974,"descriptionPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","id":"f1bdce17-4ab5-49ab-9dbc-6d96a5619846","lists":[{"text":"What You Will Do","content":"<li>Support Area Head to drive consumer engagement focus areas in terms of Visibility &amp; Partnership which will deliver POI domination, POS merchants branding, standard package that will deliver Area target completed orders and active users</li><li>Managing all day to day marketing executional activities from all areas needed to deliver the consumer engagement plans. e.g. contract, PO, invoice, etc.</li><li>Ensure all consumer engagement activities in areas are delivered with a given standard of accuracy, completeness, timeliness as per the standard package and local initiatives</li><li>Externally supervise vendors/daily workers in executing merchant branding and POI domination on a regular basis</li><li>&nbsp;Internally work with direct responsibility to deliver area executions and targets by executing events, exhibits, and other activities</li><li>Good with data to develop and execute clear integrated strategies of digital marketing with clear metrics and excellent results</li><li>Responsible for setting the integrated communications plan and ensuring consistency of messaging and brand communications. Working closely with the sales, government relations, and operations team</li>"},{"text":"What This Role Needs","content":"<li>At least 2&nbsp; years of working experience in Marketing/Sales</li><li>Good understanding of local knowledge</li><li>Strong analytical and planning skills</li><li>Good communication and presentation skills</li><li>Excellent problem-solving skill with the ability to play it well independently and in a team</li><li>Good collaboration with compassion and proactiveness</li><li>Agile and fast in thinking and execution</li><li>Have exposure of working at a top global FMCG company would be a plus point</li>"}],"text":"Area CE Associate - Semarang - #10227","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","descriptionBodyPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846","applyUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720169838701,"descriptionPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><span style=\"font-size: 10pt\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","lists":[{"text":"What you will do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;</li><li>driver acquisition management</li><li>driver engagement management (loyalty &amp; retention and safety &amp; performance training)&nbsp;</li><li>driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant)</li><li>driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li><div><br></div>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Having good understanding about supply and demand planning</li><li>Having experience in managing a small team (&gt; 3 members)</li><li>Having good communication skills and good attention to detail and routine activities</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Able to handle communication in community or mass conflict&nbsp;</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written in English</li>"}],"text":"Area Operations Manager - Bekasi","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","applyUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb/apply"},{"additionalPlain":"About the team \n\nArea Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the team </b></div><div><br></div><div><span style=\"font-size: 16px\">Area Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Depok","team":"-","allLocations":["Depok","Bogor"]},"createdAt":1713768982209,"descriptionPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"18674f77-24b2-46a4-86bb-7b5e7fe71f2c","lists":[{"text":"What You Will Do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;Driver acquisition management, Driver engagement management (loyalty &amp; retention and safety &amp; performance training), Driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant), driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li>"},{"text":"What You Will Need","content":"<li>At least 5 years experience in operations/ supply/ demand generation, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Good understanding about supply and demand planning</li><li>Prior experience in managing team (&gt; 3 members)</li><li>Good communication skills and good attention to detail and routine activities</li><li>Ability to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Capability to handle communication in community or mass conflict&nbsp;</li><li>Proficiency in English both spoken and written</li>"}],"text":"Area Operations Manager (Bogor Depok)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c","applyUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c/apply"},{"additionalPlain":"About The Team\n\nOur Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners. \n\nOne of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team. \n\nOur team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">One of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"-","allLocations":["Tangerang"]},"createdAt":1716869065162,"descriptionPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","id":"8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","lists":[{"text":"What You Will Do","content":"<li>List, identify, and propose solutions to our driver partners' problems on the field and ensure their concerns are heard by following up with them</li><li>Manage offline engagement (i.e. 'kopdar') as our way to inform, reach, and engage with driver partners</li><li>Ensure all engagement programs are well executed and implemented</li><li>Handle driver support unit according to agreed operating office hours</li><li>Support implementation of Gojek's policies/programs by managing these changes</li><li>Propose activities/programs to engage our driver partners</li><li>Monitor personal metrics of engagement with driver partners, and propose solutions to increase the level of engagement</li>"},{"text":"What You Will Need","content":"<li>A Bachelor's degree (fresh graduates are welcome to apply!)</li><li>At least 1 year of experience in supply chain, preferably at a multinational company</li><li>Strong analytical thinking and problem-solving skills to effectively resolve driver-related issues</li><li>Strong interpersonal skills in order to cater and build relationships with various stakeholders</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Sharp attention to detail to increase productivity and reduce the likelihood of errors</li><li>Excellent planning and organizational abilities to ensure the area team is on track to achieve its goals</li><li>An understanding about/familiarity with the Tangerang region</li>"}],"text":"Area Operations Staff","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","descriptionBodyPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","applyUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2/apply"},{"additional":"","additionalPlain":"","categories":{"department":"ODS - Regions","location":"Balikpapan","team":"Emerging Market","allLocations":["Balikpapan"]},"createdAt":1719223321521,"description":"","descriptionPlain":"","id":"95ee9a06-a46d-43a2-a8e7-003de776404d","lists":[{"text":"What you will do:","content":"<li>Handle all the driver community, marketing, and driver care responsibilities on areas level and channel walk in center on each area;</li><li>Ensure problem solving according to agreed process &amp; based on standard operational procedure;</li><li>Manage driver’s problems and empowerment;</li><li>Coordinate with Area Operations Manager for day-to-day escalated issues around driver service and customer service to manage service time, driver and customer satisfaction;</li><li>Developing the marketing strategy for the company in line with company objectives;</li><li>Conceptualizes events, exhibits and other below the line marketing based on the marketing plan, and evaluate the effectiveness of all marketing activities;</li><li>Maintain effective internal communications to ensure that all relevant company functions are kept informed of marketing objectives.</li>"},{"text":"What you will need:","content":"<li>Having a minimum of 3 years experience in related fields;</li><li>Bachelor degree from top university any well-known universities from each region with GPA &gt; 3.2 or equivalent;</li><li>Passionate about community development, having relevant previous experience would be preferred;</li><li>Experience launching community initiatives (building an online forum, launching an ambassador program, creating an event series, etc.);</li><li>Ability to identify and track relevant community and market metrics;</li><li>Excellent verbal communication and writing skills;</li><li>Having a basic of data analytics;</li><li>Willing to relocate to a selected area.</li>"}],"text":"Area Operations Supervisor - Balikpapan","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d","applyUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d/apply"},{"additionalPlain":"About the team\n\nThis position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team. \n","additional":"<div><b>About the team</b></div><div><br></div><div>This position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team.&nbsp;</div>","categories":{"department":"ODS - Regions","location":"Makassar","team":"Emerging Market","allLocations":["Makassar"]},"createdAt":1721716492787,"descriptionPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","description":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","id":"20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","lists":[{"text":"What Will You Do","content":"<li>Develop and implement procedures for effective sales support administration;</li><li>Monitor and analyze sales support team performance to identify areas for improvement and implement strategies to increase efficiency;</li><li>Ensure all sales inquiries and issues are addressed promptly and accurately, with a focus on improving merchant satisfaction &amp; topline sales metrics;</li><li>Coordinate with the merchant sales team to streamline sales processes and remove obstacles in the sales cycle;</li><li>Execute GoFood onboarding timely &amp; ensure that there is no backlog</li><li>Able to understand KYC follow up reasons based on FAQ and able to know when to escalate</li><li>Collaborate with other departments to ensure sales and marketing strategies are aligned and support the overall goals of the organization;</li><li>Assist in the development and implementation of sales policies and practices that drive sales effectiveness.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree in Business Administration, Marketing, or a related field;</li><li>Minimum of 3 years of experience in sales support, account management, customer service, sales-marketing administration related or a supervisory role within a sales-focused organization;</li><li>Strong customer/merchant partner focus and project management skills preferred;</li><li>Has data reporting skills, preferred both Bahasa Indonesia and English;</li><li>Strong analytical and problem-solving abilities by utilizing e.g. Google Sheet, etc;</li><li>Detail and deadline oriented;</li><li>Strong stakeholder management and cross-functional collaboration;</li><li>Able to adapt in a fast-changed environment.</li>"}],"text":"Area Sales Support Supervisor (Sulampa)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","descriptionBodyPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","applyUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450/apply"},{"additionalPlain":"About The Team\n\nOur tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!  \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">Our tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!&nbsp;&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697204557563,"descriptionPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","description":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","id":"56966262-038f-497f-84c1-f360a9440c55","lists":[{"text":"What You Will Do","content":"<li>Manage tax compliance matters; including preparation of monthly and annual tax calculation/payment/returns, i.e. WHT, VAT, CIT)</li><li>Manage and advise day-to-day business initiatives including decisive actions toward dynamic business products</li><li>Manage and handle restructuring projects independently with supervision from the AVP of Tax</li><li>Able to communicate and align with relevant stakeholders within the group</li><li>Monitoring any tax regulation updates, identifying relevant business areas that may be impacted, and planning the risk mitigation strategy</li><li>Able to support the litigation process and assessment of risks</li><li>Able to support the advocacy initiatives within the relevant external organizations.</li>"},{"text":"What You Will Need","content":"<li>S1 Bachelor of Economics (majoring in accounting or corporate finance) or Bachelor of Social Finance (Majoring in Fiscal Administration) </li><li>Minimum 5 years of working experience in the taxation field</li><li>Strong interpersonal, analytical, communication, and presentation skills with advanced command of written and spoken English</li><li>Strong technical skills in tax, accounting, and corporate finance</li><li>Ability to work in a fast-paced, rapidly changing, and high-growth environment</li><li>Able to work independently and in a team</li>"}],"text":"Assistant Tax Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","descriptionBodyPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55","applyUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721353652294,"descriptionPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","description":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","id":"325ee617-30f3-41c1-a022-6577bd82faf0","lists":[{"text":"What You Will Do","content":"<li>Collecting and importing data from various sources into databases.</li><li>Cleaning and preprocessing data to ensure accuracy and consistency.</li><li>Analyzing datasets to identify trends, patterns, and insights.</li><li>Creating and maintaining data visualizations and dashboards.</li><li>Generating regular and ad-hoc reports for stakeholders.</li><li>Collaborating with team members and stakeholders to understand data needs and requirements.</li><li>Monitoring data quality and integrity, addressing any discrepancies.</li><li>Utilizing programming languages (e.g., SQL, Python) and tools (e.g., Sheet) for data manipulation and analysis.</li>"},{"text":"What You Will Need","content":"<li>Technical Skills: Proficiency in SQL, Python, and Sheet for data manipulation and analysis.</li><li>Analytical Skills: Strong analytical and problem-solving skills to interpret data and create actionable insights.</li><li>Reporting Tools: Familiarity with tools for generating reports, such as Sheet, Metabase, or Looker Studio.</li><li>Communication Skills: Ability to communicate findings and insights effectively to non-technical stakeholders..</li>"}],"text":"Business Analyst - GoPay","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt;\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt;\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","descriptionBodyPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0","applyUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716278898371,"descriptionPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","description":"<div><span style=\"font-size: 16px\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","id":"2242125a-7155-4353-bc79-473d237d6808","lists":[{"text":"What You WIll Do","content":"<li>Be the expert in using data to measure and analyze business performance.</li><li>Explore business issues/opportunities, uncover insights and/or identify targeted areas for business growth.</li><li>Lead new data analytics capability rollouts and/or data-led initiatives throughout organization.</li><li>Monitor key metrics and alert the business on potential issues.</li><li>Analyze operational efficiency and build business models to guide decision-making.</li><li>Design market/business intelligence reports and performance measurement dashboards to share with senior management.</li><li>Able to analyze business performance following the analysis framework.</li><li>Able to create reports/ dashboards individually.</li><li>Collaborates with business stakeholders to gather requirements and deliver actionable insights.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Statistics, Business Administration, or a related field.</li><li>2-5 years of experience in a BI or analytics role.</li><li>Proficiency in SQL and database management systems like MySQL, SQL Server, or Oracle.</li><li>Advanced knowledge of data modeling and data warehousing concepts.</li><li>Strong understanding of business processes and the ability to translate business requirements into technical solutions.</li><li>Familiarity with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Experience with BI reporting tools and dashboard development.</li><li>Proven ability to work with cross-functional teams and manage stakeholders.</li><li>Familiarity with business operations in the field.</li>"}],"text":"Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","descriptionBodyPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808","applyUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808/apply"},{"additionalPlain":"About The Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119647983,"descriptionPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><b style=\"font-size: 16px\">Job Scope</b></div><div><span style=\"font-size: 16px\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px\">6 Months Challenge</b></div><div><span style=\"font-size: 16px\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","id":"9a8977f6-ea32-40e0-bb09-d3330c40d056","lists":[{"text":"What You Will Do","content":"<li>Monitor performance metrics and adjust processes as needed</li><li>Build relationships with stakeholders to support process optimization initiatives</li><li>Leverage technology to automate tasks and improve accuracy</li><li>Focus on enhancing customer experience in building automated support processes</li><li>Ensure high-quality service delivery to customers</li><li>Implement changes to streamline workflows and enhance efficiency</li>"},{"text":"What This Role Needs","content":"<li>At least 5 years working experience in related field</li><li>Strong analytical and problem-solving skills</li><li>Experience in process optimization and workflow management</li><li>Proficiency with automation tools and technology</li><li>Excellent communication and coordination abilities</li><li>Ability to prioritize tasks and manage time effectively</li><li>Knowledge of customer experience best practices</li><li>Familiarity with fintech industry standards and trends</li><li>Collaborative mindset to build relationships with stakeholders</li>"}],"text":"Business Operations Analyst (Trust and Safety) - GoPay - #10311","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><b style=\"font-size: 16px;\">Job Scope</b></div><div><span style=\"font-size: 16px;\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px;\">6 Months Challenge</b></div><div><span style=\"font-size: 16px;\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","descriptionBodyPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056","applyUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264950378,"description":"","descriptionPlain":"","id":"73e71b86-d53f-4841-92ec-4bd09a0ef479","lists":[{"text":"What You Will Do","content":"<li>explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across the Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs..</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Data Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479","applyUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716265340466,"description":"","descriptionPlain":"","id":"36d71dff-c9ac-44b8-b870-f74d941bd7d3","lists":[{"text":"What You Will Do","content":"<li>Design and implement complex data solutions, architecting data systems, and driving technical initiatives.</li><li>Optimize data infrastructure for performance, scalability, and reliability - working with large-scale data volumes &amp; distributed systems.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Provide technical guidance and support to ensure the successful delivery of data projects, including troubleshooting and resolving technical challenges.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>5+ years of experience in data engineering, software engineering, or a similar role.</li><li>Expertise in programming languages such as Python, Java, or Scala.</li><li>Advanced knowledge of SQL, database management systems, and data warehousing concepts.</li><li>Extensive experience with big data technologies and distributed systems.</li><li>Proven track record of designing and implementing complex data pipelines and ETL processes.</li><li>Deep understanding of cloud-based data technologies and best practices.</li><li>Leadership abilities to mentor junior team members and lead technical initiatives.</li><li>Strong problem-solving and troubleshooting skills.</li><li>Ability to communicate technical concepts effectively to both technical and non-technical stakeholders.</li>"}],"text":"Data Engineer Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3","applyUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3/apply"},{"additionalPlain":"About the Team\n\nThe Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience. \nAs a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience.&nbsp;</div><div>As a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1717749466111,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","description":"<div><span style=\"font-size: 10pt\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","id":"d93a7524-8ab9-4499-9f04-0876fcafa529","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain performance management dashboards and visualizations.&nbsp;</li><li>Provide regular analysis on operational performance metrics including transactions, conversion rate, lead quality, cost efficiency, retention, and KPI tracking to guide decision-making and devise proactive solutions.&nbsp;</li><li>Collaborate across teams to drive Operational Excellence (OPEX) and Continuous Improvement Process (CIP) initiatives, identifying growth opportunities for product, customer, driver, and optimization.&nbsp;</li><li>Support senior management with clear and concise presentations of complex data sets for informed decision-making.&nbsp;</li><li>Build, automate, and enhance reporting, data logging, and data pipelines for availability, integrity, accuracy, and reliability, ensuring security and compliance.&nbsp;</li><li>Assist in report compilation, issue investigation, and liaison with internal and external stakeholders for regulatory compliance.</li>"},{"text":"What You Will Need","content":"<li>Bachelors' Degree in Economics, Computer Science, Engineering, Mathematics or Statistics.&nbsp;</li><li>Minimum 5 years experience with 3+ years of relevant experience in analytics and product/process improvement.&nbsp;</li><li>Proficient in analyzing large datasets and translating quantitative findings into actionable insights.&nbsp;</li><li>Excellent understanding of analytics, computational modeling, business needs analysis, data visualization, and stakeholder management.&nbsp;</li><li>Resilience and initiative in a fast-paced, dynamic environment&nbsp;</li><li>Proficient in SQL; experience in BI tools such as Tableau, Metaforce, Python or Looker is a plus&nbsp;</li><li>Prior experience demonstrating strong stakeholder engagement and vendor management skills is a plus</li>"}],"text":"Data Operations Analyst","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529","applyUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Internship","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719909376581,"descriptionPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","id":"816f2d4c-5ff6-4e83-8697-9c25df599409","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li><b>Fresh Graduates </b>from computer science, mathematics, or statistics<b>&nbsp;</b>(Students on final semester are also preferred)</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Data Scientist Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409","applyUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409/apply"},{"additionalPlain":"Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.\n","additional":"<div><span style=\"font-size: 10pt\">Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718963848611,"descriptionPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","description":"<div><span style=\"font-size: 9pt\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","id":"5d07cd21-8826-4de7-9ad4-15909a0c5c37","lists":[{"text":"What you will do","content":"<li>Devise and implement tailored digital marketing strategies for GoRide, GoCar, GoSend, and GoShop</li><li>Analyze market trends to identify growth opportunities and refine strategies accordingly</li><li>Collaborate cross-functionally to ensure alignment with business goals</li><li>Monitor and evaluate campaign performance to drive optimization</li><li>Stay updated on industry trends and technologies to drive innovation</li><li>Manage relationships with external partners and agencies to support initiatives</li><li>Contribute to overarching marketing strategies and brainstorming sessions.</li><div><br></div>"},{"text":"What you will need","content":"<li>3+ years of digital marketing experience</li><li>Proficiency in digital marketing tools and platforms such as Google Adwords, Meta, TikTok Ads, Google Analytics &amp; Data Studio/Looker</li><li>Strong analytical, communication, and problem-solving skills</li><li>Bachelor's degree in Marketing, Communications, or related field</li><li>Fluency in English. </li><div><br></div>"}],"text":"Digital Marketing Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","descriptionBodyPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37","applyUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37/apply"},{"additionalPlain":"The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1722240835278,"descriptionPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","description":"<div><span style=\"font-size: 9pt\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","id":"eb38692a-8133-4cd2-a793-f5d75ee8841a","lists":[{"text":"What You Will Do","content":"<li>Accountable for leading the driver onboarding and support team, ensuring a quick and seamless experience for driver-partners at the GoHub</li><li>Management of day-to-day operations of the team, including communications and KPI performance management</li><li>Drive results through strong internal and external collaboration to improve the quality and efficiency of the team</li><li>Support &amp; drive operational requirements, to achieve and exceed team productivity and service level targets</li><li>Responsible for the design, deployment and maintenance of processes arising from new product launches and enhancement to existing process flows</li><li>Understand reporting needs and provide appropriate data analysis on performance metrics for stakeholders</li><li>Work with relevant stakeholders to identify and prioritize improvement initiatives and other cross-functional projects</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience as an operations manager in a contact center / frontline customer service operations</li><li>Experience in managing teams, motivating, coaching and inspiring team members to achieve excellent customer experience</li><li>Address conflicts and interpersonal issues within the team professionally and diplomatically</li><li>Ability to make informed decisions under pressure, considering both short-term and long-term implications</li><li>Keen eye for detailed process steps &amp; identification of gaps/opportunities</li><li>Strong stakeholder and project management capabilities</li><li>Efficiently manage time, resources, and priorities to ensure productivity and meet deadlines</li><li>Keep customer needs in mind when making decisions and managing operations</li><div><br></div>"}],"text":"Driver Care Lead, Hub Operations","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","descriptionBodyPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a","applyUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a/apply"},{"additionalPlain":"About Us\n\nWe are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nAlong with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1714628452648,"descriptionPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px\">&nbsp;</span></div><div><span style=\"font-size: 16px\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","id":"dfe98505-36d8-4467-aa36-df8599ab69d8","lists":[{"text":"What You Will Do","content":"<li>Assess and manage team performance through staff meetings, one on ones, and quarterly assessments</li><li>Mentor your engineers to ensure their growth and engagement in the team, evaluate team workload and develop a staffing plan, and assign projects and balance workload to ensure continuous delivery and higher predictability</li><li>Serve as primary interface to staffing team, creating job descriptions, identifying sources for candidates, conducting interviews and shepherding candidates through the process</li><li>Lead a team of Software Engineers focused on improving velocity and impact across Gojek’s diverse project areas and platforms</li><li>Become a partner to Product Managers on deciding vision, strategy and OKRs</li><li>Provide technical expertise throughout the product life cycle including design, implementation, and delivery of scalable build/test/release infrastructure</li>"},{"text":"What You Will Need","content":"<li>Having at least 8 years of relevant software development experience preferably with experience in data products, also at least 2 years of leading and mentoring an engineering team to success</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, TDD and Test Engineering, and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate dependency risks</li><li>Ability to review the code and ensure code maintainability as part of new product enhancements.</li>"},{"text":"Bonus Points If","content":"<li>Understanding in data modeling for data warehouse, relational database, and non-relational database</li><li>Understanding in batch and stream data pipeline; Beam, Flink, Spark</li>"}],"text":"Engineering Manager - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px;\">&nbsp;</span></div><div><span style=\"font-size: 16px;\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8","applyUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8/apply"},{"additionalPlain":"About the Team\n\nThe Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721370013113,"descriptionPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","id":"178ba514-705f-4f0b-9e48-fe917c47a95b","lists":[{"text":"What You Will Do","content":"<li>Continuously monitor, review, maintain, and improve security controls that are used to secure GoTo enterprise IT systems and SaaS services;</li><li>Review and implement initiatives to improve the security posture of GoTo enterprise IT systems and SaaS services;</li><li>Perform security hardening on GoTo IT systems and SaaS services;</li><li>Support the remediation of relevant security issues relevant to GoTo corporate IT systems and SaaS services;</li><li>Provide answers and recommendations to security-related questions, queries, and requests related to GoTo enterprise IT systems and SaaS services;</li><li>Develop, review, and improve technical documentation and reports relevant to the security controls used by GoTo corporate IT systems and SaaS services.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, networking, and general security concepts (a bachelor's degree or higher is a plus).</li><li>At least 5 years of experience in cyber security, preferably with hands-on experience in implementing and maintaining the security of enterprise grade IT systems and SaaS services, e.g., Google Workspace, Microsoft 365, Slack, SAP, or Atlassian;</li><li>Proven hands-on experience in the configuration and troubleshooting of enterprise security solutions, e.g., EDR, MDM, DLP, Firewall, and/or SASE;</li><li>Proven hands-on experience in the management and security of enterprise collaboration tools such as Google Workspace, Microsoft 365, or Lark;</li><li>Coding and scripting skills especially for automation is highly desired;</li><li>Ability to develop clear and concise documentation and reports.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Enterprise Information Security Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","descriptionBodyPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b","applyUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b/apply"},{"additionalPlain":"About The Team\n\nCost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Cost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.</div>","categories":{"commitment":"Permanent","department":"FinTech - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718852731439,"descriptionPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","id":"60283bc5-9f60-400a-8289-bcbe332fbc09","lists":[{"text":"What You Will Do","content":"<li><b>Planning</b>: Work closely with the budget owner to prepare annual budget planning, re-forecast, rolling forecast on a periodic business cycle. Review budget activities completed by the budget owner with accurate baseline, information, and proper justification</li><li><b>Controlling</b>: Responsible for reviewing and approving each spending related to Opex and Capex according to the applicable Expense Management PolicyWork closely with the budget owner to ensure each spending request is based on business requirements, supported by budget availability, and budget transfer process (if required). Collaborate with the other stakeholders in building the right cost base e.g., Procurement, Budget owner, etc.</li><li><b>Monitoring</b>: Create and refine report in order to provide the right data and information to the CFO, FBP and Budget Owner to analyze the actual spends against the available budget on monthly basis with a pre-defined report including its associated drivers. Understand the variance including the explanation and/or justification from the Budget Owner whenever the spend exceeded the approved budget. Continue to work closely with the Budget Owner in supporting the identification of risks &amp; opportunities for cost-efficiency purposes. Highlight key financial issues and deliver the proposed solutions to the stakeholders, provide insightful financial analysis on a regular and ad-hoc basis such as but not limited to topline daily/weekly tracker, business unit performance review, and other financial ratios analysisIn certain circumstances, this candidate will work with Cost Management Head to support the entire products under GoTo Financial product or Function group.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's Degree in Accounting / Finance/ Business, or equivalent educational background</li><li>Minimum 5 years of working experience in Finance Business Partner / Cost Control areas</li><li>Able to build a financial model, proficiency in Microsoft Excel and Gsheet/Gdocs</li><li>Strong business, data-driven acumen, and ability to work with big database</li><li>Able to manage multiple stakeholders across various levels of seniority</li><li>Strong project management skills to manage complex projects; able to prioritize multiple internal and external stakeholders; and able to drive consensus</li><li>Strong team player; possesses team synergy skills with a high level of enthusiasm in collaborating with cross-teams</li><li>Able to work independently and high attention to detail with swift execution</li><li>Proficiency with Finance / Accounting tools (e.g. SAP and ERP) is a plus</li><li>Fluent in English (written and spoken)</li>"}],"text":"Financial Controller Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","descriptionBodyPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09","applyUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09/apply"},{"additionalPlain":"About the team \n\nThe Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. \n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. </div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721025492852,"descriptionPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","id":"a9daeacc-5dda-4735-ad7b-db35eb7593a6","lists":[{"text":"What you will do","content":"<li>Support Compliance and Regulatory Affairs matters in GoTo Financial Services operations, which includes but is not limited to business/product reporting and approval process with the regulators, compliance advisory assistance to business unit, as well as technical regulatory assessment</li><li>Provide Compliance advisory assistance for Financial Services operations, in both consumer and merchant-facing operation</li><li>Create and maintain the latest update of Financial Services regulations databases and provide/disseminate assessments on such regulations to the internal units in GoTo Financial</li><li>Provide assistance and support to the Head of Compliance and Senior Manager of Financial Services Compliance in any external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders</li><li>Give continuous support on the creation, standardization, and implementation of Financial Services Compliance, policies, terms &amp; conditions, internal working procedures, and standard operational guidelines</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law and Accounting. Having a master’s degree would be an advantage.</li><li>Possessing certifications in Risk Management/ IT Audit will be an advantage.</li><li>At least 4 years of mixed experience in the area of payment policy/ regulatory compliance.</li><li>Intermediate level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks, proactively choose the best solutions, and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including builds credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"FinServ Compliance Officer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6","applyUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705377654170,"descriptionPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","id":"a3543985-6d2c-45cf-84f7-312ec7efed36","lists":[{"text":"What Will You Do","content":"<li>Write and deploy code that's clear, concise, performant, tested, and easy to understand by other teams and engineers</li><li>Participate in design reviews and own feature development from end to end</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices</li><li>Deep dive and debug production issues across services and levels of the stack when needed</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently</li>"},{"text":"What Will You Need","content":"<li>5+ years experience building consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Proficiency with one or more programming languages like Java, Go, and Kotlin.</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, asynchronous programming, fault tolerance and monitoring, performance, feature flags</li><li>Understanding how mobile/web applications interact with back-end and other systems. Experience in building frontend UIs is a bonus</li><li>Good understanding of SQL/NoSQL databases</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, GCP</li><li>Excellent verbal and written communication skills</li><div><br></div>"}],"text":"Full Stack Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","descriptionBodyPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36","applyUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36/apply"},{"additionalPlain":"About the Team :\nWe are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \nThis includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team :</b></div><div><span style=\"font-size: 10pt\">We are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><span style=\"font-size: 10pt\">This includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><span style=\"font-size: 10pt\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718186798651,"descriptionPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","id":"6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","lists":[{"text":"What You Will Do","content":"<li>Build highly reliable frontend apps through appealing visual design with API integrations to support continuing increases in adoption of the products within Gojek</li><li>Work with engineers to understand the nature and background of the problems.</li><li>Work closely with all Data Platform teams to develop and rollout high quality products</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Contribute to improving team relatedness, and helps build a culture of camaraderie</li><li>Continuously refactor applications to ensure high-quality</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript.</li><li>Solid command over React JS with the flavor of TypeScript.</li><li>Keen design and UX sense to analyze and understand the designs and wireframes.</li><li>Good understanding of common web security threats and practices along with OWASP 10.</li><li>Experience with <a href=\"http://node.js\" class=\"postings-link\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server.</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management.</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Fullstack Engineer - Engineering Platforms","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt;\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt;\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","descriptionBodyPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","applyUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720422707435,"descriptionPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","description":"<div><span style=\"font-size: 10pt\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","id":"1a011faf-f8c7-4531-b2ed-c3837dd521f0","lists":[{"text":"What you will do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What you will need","content":"<li>At least 5 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closing</li><li>Excellent in contract and commercial negotiation process</li>"},{"text":"About the team","content":"<li>Ready to join a team that shapes the future of new leading transformation in Gojek business as GoCorp Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in GoCorp platform for businesses to manage employees’ transport needs with Gojek services. </li>"}],"text":"GoCorp Sales Senior Manager (Enterprise & SMB)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt;\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","descriptionBodyPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales team that focusses on SOE and Government,, you'll play a pivotal role in shaping the foundation and execution of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a011faf-f8c7-4531-b2ed-c3837dd521f0","applyUrl":"https://jobs.lever.co/GoToGroup/1a011faf-f8c7-4531-b2ed-c3837dd521f0/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</div><div>We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</div><div>Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718006842841,"descriptionPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","id":"7d1c915f-ac53-4a2c-887a-41bbbda48a26","lists":[{"text":"What You Will Do","content":"<li>Execute design tasks such as layout composition, image editing, typography, and color correction</li><li>Assist in the development of design concepts for various marketing collateral, including digital advertisements, print and digital materials, and more</li><li>Support the Art Director to provide visual assets for video and key visuals productions</li><li>Think creatively to generate visuals that connect with target audiences</li>"},{"text":"What You Will Need","content":"<li>A bachelor’s degree, with 3 years of experience in a related field</li><li>Proficiency in design software such as Adobe Creative Suite (Photoshop, Illustrator, and Premier), with a basic understanding of design principles and techniques</li><li>A portfolio showcasing examples of design work</li><li>Strong attention to detail and a passion for visual storytelling, with the ability to create compelling designs that resonate with the target audience</li><li>A can-do attitude with a determination to see tasks through to completion</li><li>Enthusiasm for design and a proactive attitude, with a desire to contribute ideas, and solve problems creatively</li>"}],"text":"Graphic Designer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","descriptionBodyPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26","applyUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26/apply"},{"additionalPlain":"About The Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Growth Analyst role will be reporting directly to the Head of Consumer Acquisition & Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Growth Analyst role will be reporting directly to the Head of Consumer Acquisition &amp; Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Consumer Experience","allLocations":["Jakarta"]},"createdAt":1721795385137,"descriptionPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","description":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","id":"5f86f9c4-80bc-437f-b09c-b61fd85c27eb","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Drive actionable insights recommendation such as making funnel conversion analysis, cohort analysis, long-term trends, user segmentation, etc.</li><li>Identify the business need and generate analysis&nbsp;</li><li>Create and manage dashboards and data pipelines to monitor metrics to measure business performance</li><li>Working closely with the Business team and other data team (Data Engineer, Business Intelligence) to implement data solution</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 2 years of working experience in data analytics field</li><li>Proficiency in data analysis tools, SQL. Strong analytical skills to interpret complex data sets and extract actionable insights.</li><li>High proficient in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficient in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Data Management: Familiarity with data collection, storage, and management best practices.&nbsp;</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li>"}],"text":"Growth Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb","applyUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb/apply"},{"additionalPlain":"About the Team\n\nThe Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720079397618,"descriptionPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","id":"9bc8bd8a-cadc-4942-81c4-193773a294df","lists":[{"text":"What You Will Do","content":"<li>Design and own growth strategy of GoPay Later product; make data-driven business decisions on a regular&nbsp;</li><li>growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps, and actual customer insights</li><li>Test and validate solutions through a proper experimentation process</li><li>Liaise with other analytical chapters within the Financial Services Platform as well as across Gojek such as Data Science, Data Engineering, Data Governance, Risk Analytics, etc, to ensure that initiatives are aligned and data integrity standards are adhered to.</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 2 years of working experience in an analytical role (data analyst / BI/data science/statistician, etc)</li><li>Strong SQL skills with expertise in either Excel/Python/R</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps</li><li>Strong project management skills to manage projects; able to work together with relevant units, also can manage and prioritize multiple internal stakeholders</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team</li>"}],"text":"Growth Analyst - GoPay Later","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","descriptionBodyPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df","applyUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713765081862,"descriptionPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","description":"<div><span style=\"font-size: 10.5pt\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","id":"761415aa-89b7-4ffb-a19b-2b91ac4243b4","lists":[{"text":"What You Will Do","content":"<li>Lead the strategy and growth function for GoModal. You will be collaborating with the Marketing &amp; Product teams on a daily basis.</li><li>Maintain rigor in analytical excellence in terms of data analytics, A/B test design, and appropriate statistical tests across the product funnel from acquisition, adoption, retention to monetization.</li><li>Discover growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps and actual customer insights.</li><li>Analyze our complex and ever-growing data, present insights, and propose strategic options to management to drive business decisions.</li><li>Test and validate solutions through proper experimentation process.</li><li>Importantly, using data to identify growth opportunities and problem solve so as to achieve business goals with metrics such as conversion rates of WL to submit KYC, adoption rate &amp; GTV (disbursement)</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 4 years of working experience in a growth or product role (growth marketing, data analyst, BI, strategy, etc).</li><li>Strong project management skill to manage complex projects; also can manage and prioritize multiple internal and external stakeholders.</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps.</li><li>Experienced planning, designing, and executing experiments. Also comfortable working with frequentist statistics to analyze experiment results.</li><li>Strong data visualization and data storytelling skills.</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team.</li><li>Preferred but not required: Strong SQL skills with expertise in either Excel/Python/R&nbsp;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Growth Lead (Merchant Lending)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","descriptionBodyPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4","applyUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714985249008,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","id":"2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Introduce beneficial business changes through well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve the business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resourcesProactively improve the operation process in the team and act on how to drive a faster, more effective, and efficient execution process through third-party tools or in-house service</li>"},{"text":"What You Will Need ","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience&nbsp;</li><li>Data analytics capability, have a good knowledge of SQL and experimentation processes; High Proficiency in Python and R is a plus</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Planning & Operation - GoFood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","applyUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e/apply"},{"additionalPlain":"About the Team \n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717479647909,"descriptionPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","id":"1fad1d82-dc7b-4d5a-b0d0-eb4678350242","lists":[{"text":"What You Will Do","content":"<li>Lead and Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Work closely with the Product, Marketing, Sales, Research, and Intelligence teams to understand merchant pain points and define the solution as well as Data, Ads, and Operation teams in the development and implementation of initiatives and strategies</li><li>Prepare reports of key merchant metrics analysis as a basis of rationale and recommendations to upper management, including CxOs of Gojek and GoTo Group</li><li>Conduct competitive benchmarking and analysis with local and international counterparts</li><li>Introduce beneficial business changes through a well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience</li><li>Strong critical thinking, coordination, and stakeholder management skills to drive analysis and cross-collaboration independently</li><li>Data analytics capability have a good knowledge of SQL and experimentation process; High Proficiency in Python and R is a plus</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also being a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Strategy Manager - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","descriptionBodyPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242","applyUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719458638459,"descriptionPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","description":"<div><span style=\"font-size: 10pt\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","id":"b68a9eb5-f615-441a-b04c-2d2c6a9d4703","lists":[{"text":"What You Will Do","content":"<li>Perform development and review of Business Continuity Management Framework and its supporting policies;</li><li>Strategize, coordinate, and provide challenge and advisory in the implementation of Business Continuity Programs such as BCP, BCP testing, Crisis Management exercise, and ways of integrating Business Continuity concept and awareness in the operational of business and support functions;</li><li>Respond to audit and regulatory requirements on BCM;</li><li>Design and deliver BCM communications and clinic sessions;</li><li>Provide Business Continuity update report to Management</li><li>Facilitate and support the execution of the plans at the time of a crisis event.</li>"},{"text":"What You Will Need","content":"<li>Minimum bachelor’s degree in relevant discipline from a reputable university</li><li>Minimum 8 years of Business Continuity Management experience in prominent consulting firms and/or multinational companies</li><li>Growth mindset, analytical, assertive and good interpersonal skill</li><li>Relevant BCM certifications&nbsp;</li><li>Good competency in English, verbal and written.</li>"}],"text":"Head of Business Continuity Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","descriptionBodyPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703","applyUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703/apply"},{"additionalPlain":"Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717651947726,"descriptionPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><span style=\"font-size: 16px\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"c838dc08-24e8-417c-9d70-a617bc58e200","lists":[{"text":"Responsibilities","content":"<li>Gojek is looking for an experienced technologist with a passion &amp; understanding of technology to lead its transportation product. Transport is one of the flagship products in GOJEK superapp. It is launched in Indonesia, Singapore and Vietnam.</li><div><br></div><li>As Head of Engineering of Transport, you will partner with GOJEK VP, Senior VP of technology, Transport Head of Business, Group Product Manager and other business stakeholders in the company to formulate a business strategy for Transport. You will work closely with PMs and Tech Leads in Transport to realize this strategy to make GOJEK a dominant player in markets.</li><div><br></div><li>Strategic thinking and strong business acumen along with deep technical expertise are essential in this role. We expect you to be well-versed in current technological trends and familiar with a variety of business concepts. If you are also an excellent communicator and public speaker, we’d like to meet you.</li><div><br></div><div>What you will do</div><div><br></div><li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Setup growth paths for the team and engage them in processes and practices that shall help scale engineering</li><li>Collaborate with cross functional teams and stakeholders (Business, Product, Data, UX, Platform, Devops etc.) to unlock the next phase of business growth.</li><li>Provide technology leadership to the team and foster engineering excellence.</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"Experience and Skills","content":"<li>Should have at least 9 years of hands-on experience in designing, developing, testing and deploying applications at scale.</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus.</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation.</li><li>Experience as people manager and passionate towards building and growing a high functioning team.&nbsp;</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions.</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities.</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Head of Engineering - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px;\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px;\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px;\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px;\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200","applyUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720423194904,"descriptionPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","description":"<div><span style=\"font-size: 10pt\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","id":"43e7dcf0-4b25-486e-b366-e2311bcb0335","lists":[{"text":"What you will do","content":"<li>Develop comprehensive sales strategies and oversee the end-to-end planning process to ensure optimal results while maintaining efficiency levels.</li><li>Define Objectives and Key Results (OKRs), metrics, and targets for the sales team to drive performance and success.</li><li>Design and implement incentive schemes, conduct end-to-end calculations, and perform industry benchmarking to enhance sales effectiveness.</li><li>Lead the go-to-market sales strategy for special projects and new products, aligning with partner needs and market demands.</li><li>Utilize data-driven analysis to derive actionable insights, fostering accelerated growth and increased operational efficiency.</li><li>Collaborate cross-functionally with product, marketing, sales, and other stakeholders to align strategies derived from data-driven analysis and execute plans effectively.</li><li>Represent the Sales Strategy team in industry events, trainings, and workshops as necessary Provide regular and ad-hoc impact reports and analyses to senior management, offering insights into performance and growth opportunities for the business.</li>"},{"text":"What you will need","content":"<li>5 years+ relevant working experience in strategy,&nbsp; business development, management consulting or other related roles that require strong analytical skills, problem-solving, and business acumen</li><li>A structured and analytical thinking process to develop frameworks, project charters and priorities</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Proficiency in basic modeling - market sizing, business projection, scenario analysis.</li><li>Have good presentation skills - esp. the ability to present during problem solving session with other stakeholders (working-level or leadership)&nbsp;</li><li>Solid track record of stakeholder management</li><li>Proficiency in SQL/query is preferred, but not mandatory (still essential in executing the role, and will need to learn basic SQL on-the-job)</li>"},{"text":"About the team","content":"<li>Ready to join a team that shapes the future of new leading transformation in Gojek business as GoCorp Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in GoCorp platform for businesses to manage employees’ transport needs with Gojek services. </li>"}],"text":"Head of GoCorp Strategy & Planning","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Be ready to be a part of a team that creates real impacts!&nbsp; As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. </span></div><div><span style=\"font-size: 10pt;\">Your efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.</span></div>","descriptionBodyPlain":"Be ready to be a part of a team that creates real impacts!  As the Sales Strategy and Planning Manager, you'll play a pivotal role in shaping the foundation and strategy of our sales team. Collaborating closely with the most talented troops, you'll path the way to our winning strategies that drive maximum value for the company. \nYour efforts will directly contribute to scaling up our business and propelling it to new heights. From structuring a high-performing sales team to crafting sharp, effective strategies, you'll have the opportunity to lead transformative initiatives and drive tangible results.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/43e7dcf0-4b25-486e-b366-e2311bcb0335","applyUrl":"https://jobs.lever.co/GoToGroup/43e7dcf0-4b25-486e-b366-e2311bcb0335/apply"},{"additionalPlain":"About The Team\nYou will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">You will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718871657577,"descriptionPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","id":"6dc20c4e-4d40-4f57-a138-4776013e454e","lists":[{"text":"What You Will Do","content":"<li>Oversee CS, Telesales, KYC, collection and FI team and Ops projects for our BNPL and cashloan product.&nbsp;</li><li>Develop &amp; Optimize Processes - Scale new and existing processes to allow the business to efficiently operate in Indonesia</li><li>Analytics - Analysis and tracking of onboarding, merchant experience and technical issues, risk management etc</li><li>Strategy - Choose which projects to prioritize, and set a timeline to reach goals quickly</li><li>Tool Improvements - Proactively search for new tools or ways which could improve a seamless support and setup experience, for both, merchant and buyer</li><li>Be fast, resourceful, and take initiative - Take ownership of regional commerce operations and do everything you can to support and enhance the quality of our services</li>"},{"text":"What This Role Needs","content":"<li>Min. 7 years experience in tech startup/fintech industry</li><li>Experience in operations strategy, sales strategy and product management is a big plus</li><li>Proven success in dynamic and complex environments, with a proven ability to rally teams and influence at all levels</li><li>Deep analytical skills, with high capacity to think strategically about complex issues, evaluate alternatives, and make compelling recommendations based on proven business case analysis</li><li>Outstanding communication skills, both verbal and written</li><li>Ability to lead complex and strategic initiatives and communicate effectively with technical teams</li><li>Ability to collaborate with various departments by utilizing superior relationship-building skills, interpersonal skills, and influence</li>"}],"text":"Head of Operation - Consumer Lending - #10162","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","descriptionBodyPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e","applyUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705905810213,"descriptionPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","description":"<div><b><span style=\"font-size: 18px\">About The Role</span></b></div><div><span style=\"font-size: 16px\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","id":"70493d8a-7d7f-4660-b1ed-c792d0d765be","lists":[{"text":"What You Will Do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What This Role Needs","content":"<li>At least 15 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Experienced in managing a huge team size</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closingExcellent in contract and commercial negotiation process</li><li>Experience in payment industry is a plus</li>"}],"text":"Head of Sales - Midtrans - #9618","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 18px;\">About The Role</span></b></div><div><span style=\"font-size: 16px;\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px;\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","descriptionBodyPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be","applyUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be/apply"},{"additionalPlain":"About The Team\nAs Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.\n\nOne of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing & executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.\n\nWe are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 14px\">As Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.</span></div><div><br></div><div><span style=\"font-size: 14px\">One of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing &amp; executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.</span></div><div><br></div><div><span style=\"font-size: 14px\">We are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Strategy","allLocations":["Jakarta"]},"createdAt":1708937527995,"descriptionPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","id":"7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","lists":[{"text":"What You Will Do","content":"<li>Design the overall end-to-end sales strategy which includes go-to-market (GTM) strategy and implied sales motions / incentives system</li><li>Define OKR &amp; building blocks for the entirety of nationwide sales team (Enterprise &amp; Small Medium Business teams) to ensure that company objectives are met - working closely with the product teams (including but not limited to GoFood, GoMart, GoCorp and GoPay)</li><li>Set sales targets in areas like product mix, sales volume, and market shares</li><li>Track OKR &amp; performance of the overall greater sales team (Enterprise, SMB Managed &amp; SMB Unmanaged teams) across all products</li><li>Oversee the execution of sales motions / building blocks: periodic review with working and/or leadership team, provide guidance to the overall sales strategy &amp; other relevant stakeholders</li><li>Establish a regular &amp; methodical planning rhythm to ensure that both sales team structure &amp; compensation plan are aligned to support reaching company targets. This would include merchant segmentation, sales structure review, sales earning optimization exercises, account mapping, territory planning; working together with the Head of Enterprise Sales and Head of SMB Sales</li><li>Become the bridge between Sales HQ &amp; on-the-ground merchant-facing teams to ensure seamless &amp; effective execution</li>"},{"text":"What This Role Needs","content":"<li>At least 10 years of relevant work experience in strategy, preferably within mid-to-senior management level from multinational company</li><li>Have strong analytical thinking and problem solving skills using various tools and methods</li><li>Comfortable working under pressure in a fast-paced and ambiguous environment</li><li>Ability to prioritize &amp; multitask across different initiatives (balancing breadth vs in-depth)</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Have great presentation skills - esp. the ability to present to senior management &amp; leadership</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>Fluent in Bahasa Indonesia &amp; English</li>"}],"text":"Head of Sales Strategy - #10056","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","descriptionBodyPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","applyUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721030934590,"descriptionPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","description":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","id":"9c0a73a5-09ce-4b06-8527-9415ef3d393c","lists":[{"text":"What You Will Do","content":"<li>Lead a team of IT Auditors in planning, preparation, coordination, and execution of audits to evaluate the adequacy and effectiveness of technology infrastructure, application, and process controls.</li><li>Provide clear, concise, and organized documentation of the audit processes and findings.</li><li>Identify and evaluate complex technology and business risks, implications, and related opportunities for improvements of internal controls.</li><li>Manage audit projects effectively – resource allocation, deliver on commitment, time management and quality reviews.</li><li>Serve as the Audit Committee Secretariat responsible for coordination of materials across the governance teams for periodic AC meetings.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Must have a minimum of 8-10 years of experience in technology audits, with at least 5 years in public accounting / advisory firms.&nbsp;&nbsp;</li><li>Must have strong practical experience in testing of GITC, application controls, ISO 27K, cybersecurity risk assessment, and ERP’s.&nbsp;</li><li>Must possess CISA certification at a minimum - additional certification in cyber, risk and technology governance preferred.&nbsp;</li><li>Knowledge and experience with OJK and Bank Indonesia (BI) technology audit requirements preferred.&nbsp;&nbsp;</li><li>Experienced with coaching and developing junior team members, strong confidence to interact with various stakeholders, excellent project management and organizational capabilities, ability to complete tasks and audit projects within tight deadlines.</li><li>Strong communication in English (verbally and in writing) and PowerPoint preparation skills.&nbsp;</li><li>Highly self-motivated, inquisitive (with a keen interest in learning new processes and technologies) and strive to continuously develop technically and professionally.</li>"}],"text":"Internal Audit Senior Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","descriptionBodyPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","hostedUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c","applyUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c/apply"},{"additionalPlain":"About The Team\n\nWe are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success\n\nWe're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>We are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success</div><div><br></div><div>We're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.</div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1721801286779,"descriptionPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","id":"ad8bd932-3494-4181-bd93-282665dce81d","lists":[{"text":"What You Will Do","content":"<li>Training Product Development: Develop and maintain detailed training materials, including manuals, user guides, and online resources, tailored to various audience levels. Collaborate with product managers, engineers, and other stakeholders to stay updated on product features and enhancements</li><li>Facilitation and Delivery: Conduct training sessions, both in-person and virtually, mainly for internal teams. Utilize a variety of instructional techniques and formats, such as role-playing, simulations, and interactive workshops</li><li>Assessment and Evaluation: Create and implement assessment tools to measure training effectiveness and knowledge retention. Gather feedback from trainees and use it to improve future training sessions</li><li>Support and Collaboration: Provide ongoing support and consultation to trainees post-training. Work closely with sales teams and internal stakeholders to address any training-related issues and ensure customer satisfaction to achieve business goals</li><li>Continuous Improvement: Stay current with the latest product developments and industry trends. Incorporate new training methodologies and technologies to enhance the learning experience.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or higher; majoring in Business, Economics, or relevant fields</li><li> 2 or 3 years of experience in a product training or related role within the tech industry. Has proven experience in developing and delivering training programs</li><li>Excellent presentation and communication skills</li><li>High attention to detail, has ability to explain complex technical concepts in a clear and accessible manner</li><li>Strong organizational and project management skills</li><li>Ability to adapt training methods to different learning styles and audiences</li><li>Ability to drive changes successfully and to keep people motivated in a highly changing environment&nbsp;</li><li>Proactive, ability to work in a team, and a strong can do attitude.</li>"}],"text":"Internal Trainer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d","applyUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d/apply"},{"additionalPlain":"Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Corporate Affairs","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1720685009263,"descriptionPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","description":"<div><span style=\"font-size: 11pt\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","id":"fc5f2c90-038e-4c53-9971-2ae72f680c03","lists":[{"text":"What you will do","content":"<li>Gojek Singapore communications:</li><div>Serve as the overall PR point of contact and develop communications strategies for the Singapore market, collaborating with the Gojek Singapore leadership team.</div><div>Develop and execute PR plans for Singapore-related announcements, handling all external-facing communications and materials.</div><div>Engage with Singapore media, manage media queries, and manage crisis and issues across media <a href=\"http://channels.Proactively\" class=\"postings-link\">ch</a>annels</div><div>Proactively seek thought leadership opportunities and lead OKR reporting for PR-related <a href=\"http://metrics.GoTo\" class=\"postings-link\">me</a>trics</div><div><br></div><li>GoTo Group communications support:</li><div>Support Group-level announcements and the development of associated English language communication materials</div><div>Maintain relationships with key international media contacts and handle media queries</div><div>Support issues management teams.</div><div>Develop thought leadership content, manage media opportunities and awards, and oversee a number of owned channels.</div><div><br></div>"},{"text":"What you will need","content":"<li>Excellent writing skills - proficiency with Chinese language media in Singapore is a bonus</li><li>Proven ability to build and maintain relationships with media contacts</li><li>Experience in pitching stories and managing media inquiries.</li><li>A cool head in a crisis</li><li>Meticulous approach to reviewing materials and ensuring accuracy</li><li>Ability to manage multiple projects without compromising quality.</li><li>Flexibility to manage unexpected challenges and opportunities</li><li>Enthusiasm for travel (regular travel to indonesia will be required) </li><div><br></div>"}],"text":"International & Singapore Communications Manager","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 11pt;\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt;\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","descriptionBodyPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03","applyUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03/apply"},{"additionalPlain":"About the Team\n\nThe IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721378203517,"descriptionPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","id":"4cb00240-117e-4ace-a959-fc567e447d5f","lists":[{"text":"What You Will Do","content":"<li>Manage multiple complex IT Finance initiatives</li><li>Ensure initiative deliveries are on time and adhere to IT Project Life-Cycle standards</li><li>Ensure information is delivered to the business through the correct channels, ensuring compliance with all controls and security requirements</li><li>Manage multiple internal stakeholders across countries and business units</li><li>Provide regular status updates to GoTo leaders and stakeholders</li>"},{"text":"What You Will Need","content":"<li>8+ years of work experience in IT project/program management in Finance Domain</li><li>Strong track record of leading successful IT projects/programs from start to finish&nbsp;</li><li>Ability to multi-task and effectively manage several projects in parallel</li><li>Ability to influence large, cross-functional teams</li><li>Strong interpersonal, facilitation, and leadership skills</li><li>Experience in managing Corporate Finance, Enterprise Data, and Enterprise business processes is highly desirable</li><li>Drive adherence to SDLC processes, drive to implement new processes and procedures applying industry knowledge and experience to cut costs, gain efficiencies, minimize risks, and reduce time to deploy, with attention towards automation and continuous improvement; make recommendations for process improvements; track and document all process improvements;&nbsp;</li><li>Good communication skills in English both oral and written</li>"}],"text":"IT Finance Project Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","descriptionBodyPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f","applyUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f/apply"},{"additionalPlain":"About the Team\n\nJoining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Joining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713930486899,"descriptionPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","id":"36caef5f-7a1c-4326-80b4-8c146060ac70","lists":[{"text":"What You Will Do","content":"<li>Develop and maintaining IT policies, standards and procedures according to applicable internal and external requirements, including the applicable regulations in Indonesia an other countries where GTF operate;</li><li>Develop and maintain compliance, governance and risk-related IT and business process flow;</li><li>Coordinating with compliance team to ensure that every initiative, development and collaboration are comply with the standards and regulations (internal and external);</li><li>Conduct routine evaluation of policies and procedures implementation and ensure best practice risk mitigation and assessment functions are maintained to comply with the company's strategy;</li><li>Coordinate with related IT work units to follow up on data requests and internal audit findings, external audits and regulators;</li><li>Develop the process and conduct the activities to safekeep or archive of every IT development document in a regular basis;</li><li>Implementing a good governance organization using the ISO27001, ISO 27701, PCI DSS framework and other relevant Technology &amp; Security best practices;</li><li>Develop and implement the RBAC and least privilege of access management in the GTF technology stack</li><li>Act as a Subject Matter Expert to the stakeholders and provide relevant &amp; applicable consultation for addressing the IT GRC requirement in lending product &amp; services.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years experiences as Information Security, IT Governance, Risk and Compliance (IT GRC) or IT Auditors;</li><li>Demonstrate excellent communication and writing skills and proficient with English written and spoken</li><li>Experienced in developing and maintaining IT and/or information security policies and procedures;</li><li>Excellent knowledge in developing risk management and IT framework, BIA, BCP and BCM Framework</li><li>Experienced in report document development and delivery;</li><li>Experienced in dealing with regulatory audit to represent the organization IT GRC operations;</li><li>Having good knowledge with local and regional payment &amp;&nbsp; lending regulatory requirements and how they impact IT policies (having experience is preferred);</li><li>Having excellent experience with ISO 27001, ITIL. COBIT, and PCI-DSS standards;</li><li>One or more of the following or equivalent certifications preferred: CISA, CRISC, ITIL, COBIT is preferred</li>"}],"text":"IT GRC Senior Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","descriptionBodyPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70","applyUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70/apply"},{"additionalPlain":"About The Team\n\nGoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.\n\nOur achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.\n\nAs a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design & Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.</div><div><br></div><div>Our achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.</div><div><br></div><div>As a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design &amp; Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720592684329,"descriptionPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","description":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","id":"da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of your Writer lead, and follow the predefined process that has been set by the team</li><li>Understand the product briefs and present ideas/solutions to the team under the supervision of your writer lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Proactively attend design reviews to gather feedback and provide critiques if needed</li><li>Proactively seek knowledge about UX</li><li>Participate in the end-to-end design process with peer researchers, designers, business, product and engineering teams. You will also get to engage with marketing and customer care unit to ensure the content is cohesive</li><li>Own your assigned streams and organize assigned tasks; which includes communicating updates and progress via the provided forums and channels. Be flexible to collaborate with other streams when needed</li>"},{"text":"What You Will Need","content":"<li>At least 1 year of experience in product writing for digital products or services</li><li>Strong understanding of writing fundamentals, critical/creative/structured thinking skills, grammar in both English &amp; Indonesian, and a familiarity of product design/ design thinking frameworks in order to further develop your writing output</li><li>Excellent communication and grammar skills in both English and Indonesian, both verbal and written, to effectively collaborate with stakeholders of varying seniority and backgrounds</li><li>A user-centric mindset in order to see things from their perspective, understand their concerns and feedback, and incorporate these insights into the work you produce</li><li>A drive to always find the root cause of an issue and validate your design - either through quantitative or qualitative research</li><li>A structured portfolio of written work that shows your ability and problem solving skills, a bonus if it demonstrates business impact and results</li><li>Ability to handle multiple tasks and prioritize work simultaneously</li><li>Demonstrate a detailed-oriented thought process with excellent documentation discipline</li>"}],"text":"Junior UX Writer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","descriptionBodyPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","applyUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d/apply"},{"additionalPlain":"About the Team\n\nTransport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.\n\nDespite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Transport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.</div><div><br></div><div>Despite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. </div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899257808,"descriptionPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","id":"f1d481f6-4e2d-401b-b310-fca641ab29d4","lists":[{"text":"What you'll do","content":"<li>Lead, mentor and recruit a team of highly talented and motivated engineers</li><li>Build and deploy features iteratively in production</li><li>Work cross-functionally with product, engineering and design teams across Gojek</li><li>Collaborate with internal teams to build and iterate on features</li><li>Build delightful user-facing experiences with smooth performance</li><li>Mentor and provide feedback to colleagues, participate in organisation building</li><li>Participate in research trips to better understand aspirations and pain points of our customers</li>"},{"text":"What you'll need","content":"<li>Should atleast have 6 years of relevant experience</li><li>Deep understanding of the iOS frameworks like UIKit, Foundation, etc.</li><li>Experience developing iOS apps in Swift</li><li>Attention to detail, particularly around software engineering fundamentals, testing methodologies, and quality</li><li>A strong customer focus</li>"}],"text":"Lead - iOS (Transport)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4","applyUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720610213311,"descriptionPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","description":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","id":"c9452ba2-cbb3-4ea5-83f7-79e765a67e58","lists":[{"text":"What You Will Do","content":"<li>As the Lead Auditor, you will support the design of risk-based audit plan influenced by regulatory compliance requirements, business needs and inputs from the governance teams (ERM, Ethics and Regulatory Compliance). You will deliver the audit as planned, discussion of issues with business and Group Audit, write up of report, advise and monitor on remediation progress. </li><div><br></div><div>Expectations of the role include: </div><div><br></div><li>Ability to deliver audit engagements independently and efficiently</li><li>Effective verbal and written communication (in Bahasa and English) of audit findings, remediation and reports to management.</li><li>Active participation and contribution to team discussion, audit planning, and stakeholder engagements.· &nbsp; </li><li>Ability to analyze operational process, regulatory issues and root cause.</li><li>Strong focus on quality deliverables such as audit report, work paper write ups, and presentation.</li>"},{"text":"What You Will Need","content":"<li>Mandatory: Minimum 8 years of audit experience obtained from public accounting and financial services internal audit roles.</li><li>Mandatory:&nbsp; Understanding and experience complying / auditing of relevant OJK regulations for multi-finance institutions.</li><li>Relevant certification in audit and risk preferred.</li><li>Highly motivated, demonstrated leadership attributes, meticulous attention to detail and problem solving</li><li>Effective communication in both Bahasa and English (verbal and written).</li><li>Ability to use data analysis tools (like ACL, MS Excel, Tableau, etc.).</li>"}],"text":"Lead Internal Auditor","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","descriptionBodyPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58","applyUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58/apply"},{"additionalPlain":"About The Team\nOur data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n","additional":"<div><b>About The Team</b></div><div>Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1719896801671,"descriptionPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","id":"4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","lists":[{"text":"What You Will Do","content":"<li>Manage data science infrastructure to streamline model development and deployment</li><li>Define and build scalable data pipelines that enables data scientists to build better models</li><li>Implement cutting edge big data frameworks to support batch and real-time jobs</li><li>Identify possible bottlenecks in the system and perform optimization</li><li>Build dashboards, models and deliver insights to support business analytics</li><li>Monitor and provide support to our infrastructure and production models</li><li>Mentoring team members through code review and knowledge sharing</li>"},{"text":"What You Will Need","content":"<li>At least 7 years of hands-on experience at large scales in data science / software engineering</li><li>Ability to write clean and structured SQL, Python and Shell programs</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Kubenetes, Docker, Infrastructure as Code, RDBMS and NoSQL Databases</li><li>Good understanding of machine learning techniques and algorithms</li><li>Good experience in serving real-time, production-level machine learning models</li><li>Management experience is preferred</li><li>Excellent communication skills</li>"}],"text":"Lead MLOps Engineer","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","descriptionBodyPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","applyUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0/apply"},{"additionalPlain":"About the Team\n\nThe GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.</div>","categories":{"commitment":"Permanent","department":"ODS - Transport & Mobility","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718255937171,"descriptionPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","id":"8bf17375-6318-400f-8216-4a132071777a","lists":[{"text":"What You Will Do","content":"<li>Roadmapping → Establish strategic objectives, roadmap and timelines to guide the development and enhancement of the GoCorp platform</li><li>Focus on optimizing the client experience, ensuring the platform meets and exceeds user needs and expectations. Execute with precision make sure products and features are launched in timely manner</li><li>Seek product ideas and feedback based on both quantitative and qualitative date, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that one size doesn’t fit all and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Work closely with business, sales, and marketing teams to align product strategies and objectives. Ensuring the all teams runs with the same drumbeat&nbsp;</li><li>Ensure seamless coordination with other product teams connected to the GoCorp platform to maintain a cohesive product ecosystem</li>"},{"text":"What You Will Need","content":"<li>Proven experience if min 5-6 years in product management, preferably within a tech or platform-based company and B2B product</li><li>Strong strategic thinking and planning skills with the ability to set and achieve the mid term and long-term objectives</li><li>Data oriented – demonstrated an ability to balance between quantitative and qualitative data to optimize client experience.</li><li>Exceptional problem-solving skills with a proactive approach to overcoming challenges</li><li>Excellent collaboration skills with experience working across multiple departments</li><li>Proficiency in managing the entire product lifecycle, from concept to launch and beyond</li><li>Strong communication skills to articulate product vision and objectives effectively to diverse stakeholders</li><li>Solid understanding of the technical aspects of platform development and integration.</li><li>Fluent in written and verbal english</li>"}],"text":"Lead Product Manager, GoCorp","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a","applyUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1716776042348,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"4a126665-42d6-4a36-82a5-089dca789f41","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Nurturing &amp; mentoring 5-7 engineers members</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize their ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 7-8+ years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Leadership experience in leading a distributed team of software engineers</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>Working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, xgboost, Keras</li><li>Prior experience with cloud provider (GCP is a plus)</li>"}],"text":"Lead Software Engineer - Data Science Platform","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41","applyUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719911495540,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","id":"a593bf17-baf2-479e-8154-c69d6a7d4f09","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost-effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems </li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure </li><li>Enhance code quality and product performance through continuous improvement and innovation </li><li>Collaborate and communicate effectively with teams across multiple geographies </li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves </li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices </li>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Erlang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with messaging protocol such MQTT &amp; prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Engineering Platforms","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09","applyUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. \n\nAt the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. </div><div><br></div><div>At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</div><div><br></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1711535878605,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","id":"3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems</li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure</li><li>Enhance code quality and product performance through continuous improvement and innovation</li><li>Collaborate and communicate effectively with teams across multiple geographies</li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves</li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in working with end to end Observability stack. Hands on experience in building and managing the telemetry pipeline at large scale</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with Grafana stack, Cortex, SLI/SLO platforms is a plus</li><li>Prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Observability","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","applyUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a/apply"},{"additionalPlain":"About the Team :\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</div><div><br></div><div>We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899083492,"descriptionPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","id":"9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences with minimal guidance for one of the world's fastest growing companies in travel</li><li>Understand, design and build to optimize in terms of resources used on the devices as well as simplify to meet the challenges of our always on-the-go users</li><li>Translate business requirements into scalable and extensible design</li><li>Partner with the product management team to define and execute the feature roadmap.Be responsible for defining and executing for complex, long term initiatives and help the team objectively lay out the roadmap and execute against smaller milestones</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Coordinate with cross functional teams (Backend, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence. Be the flag bearer for setting long term execution strategies and bring about the culture of operational excellence in the team</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in Android application development and product delivery</li><li>Predictability and balance of product delivery speed and quality</li><li>In depth knowledge of Android Apps architecture and implementation including proficiency in Kotlin, Architectural Components, Git, and Gradle</li><li>Understanding of TDD, Dependency Injection principles, Mobile Performance Tuning (Load time, Crash/ANR/Memory Leak tracking, Network optimisations)</li><li>Strong problem solving and analytical skills and a proven track record of being able to respond effectively to customer situations</li><li>A command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>A track record and passion for improving the code structure and architecture to improve testability and maintainability</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><div><br></div>"}],"text":"Lead Software Engineer - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","applyUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1704273923584,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","id":"2d3aae20-ff7e-4afb-8164-a351661c1680","lists":[{"text":"What You Will Do ","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest-growing company in the transportation industry&nbsp;</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Partner with the product management team to define and execute the feature roadmapCoordinate with cross-functional teams (Mobile, DevOps, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building the next generation of Gojek services</li>"},{"text":"What You Will Need ","content":"<li>Should have at least 6 years of hands-on experience in designing, developing, testing and deploying applications on Java or Go for large scale applications</li><li>Proficient in System Design, OOP, SQL, Linux/Unix, and Design Patterns. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities, through self-discovery or by vouching for exploratory tasks</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Lead Software Engineer (IC) - Go-Food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680","applyUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713944910535,"descriptionPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","id":"cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Proactively establish and strengthen relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia.</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals.</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors.</li><li>Project Leadership: Lead multiple projects in partnership with government institutions, focusing on Tech and the Digital Economy.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances.</li><li>Project Management: Oversee public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred.</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government.</li><li>Established network among government stakeholders with a proven impact on policy decisions.</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Manager of Food & Groceries Regulatory","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","applyUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719989851823,"descriptionPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","description":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","id":"ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","lists":[{"text":"What You Will Do","content":"<li>Maintain MI’s automation backend availability on Google Cloud Project&nbsp;</li><li>Continuously developing data pipeline architecture to ensure excellent performance&nbsp;</li><li>Do complex data analysis which are related to the Market Intelligence topics</li><li>Continuous knowledge update on latest tech capability to enhance the Market Intelligence deliverable in terms of depth, speed and variety of sources of references</li><li>Build and maintain a playbook for Market Intelligence data engineering projects</li>"},{"text":"What You Will Need","content":"<li>At least 2 years in <b>Data Engineer </b>roles</li><li>Talks in Python &amp; Linux</li><li>Exposure to data modelling would be preferred</li><li>Loves to experiment on the latest tech trends</li><li>Passionate in problem-solving and Root Cause Analysis (RCA)</li>"}],"text":"Market Intelligence (Data Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","applyUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4/apply"},{"additionalPlain":"Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.\n\nAs a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. \n","additional":"<div><span style=\"font-size: 9pt\">Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.</span></div><div><br></div><div><span style=\"font-size: 9pt\">As a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. </span></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720579532578,"descriptionPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","description":"<div><span style=\"font-size: 9pt\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","id":"967cfe0a-0243-4a2d-8813-038c355e43c3","lists":[{"text":"What you will do","content":"<li>Manage the marketing budget and ensure efficient allocation as well as prepare the report and regularly present it to senior management</li><li>Lead marketing metrics development, monitoring, and performance analysis periodically, as well as identify areas for <a href=\"http://improvement.Stay\">improvement.</a></li><li><a href=\"http://improvement.Stay\">Stay</a> updated on industry trends and the competitive landscape to inform strategic decision</li><li>Lead marketing campaigns development, monitoring, and evaluation incl. creative &amp; media strategy development &amp; execution with relevant stakeholders</li><li>Actively collaborate across functions &amp; streams especially product and strategy &amp; planning team in growing Transport business.</li><div><br></div>"},{"text":"What you will need","content":"<li>Bachelor's degree from a reputable university or equivalent practical experience</li><li>Min 4 years of experience working in a brand or product marketing field in FMCG, technology, telecommunication, or start-up</li><li>Excellent written &amp; verbal communication abilities at the business level with strong presentation skills to represent the Marketing team in functional meetings</li><li>Ability to work in a fast-paced, deadline-driven, and VUCA (volatile, uncertain, complex, and ambiguous) work environment</li><li>Strong capacity planning and reporting abilities; strong commercial sense and logical thinking skills to think outside the box as well as an understanding of budgeting, financial planning, and marketing <a href=\"http://metrics.Strong\">metrics.</a></li><li><a href=\"http://metrics.Strong\">Strong</a> analytical and quantitative skills; ability to use hard data and metrics to back up assumptions, and recommendations, and drive actions.&nbsp;</li><li>Familiarity with data analysis tools and software (SQL, Tableau, and Google Analytics)</li><div><br></div>"}],"text":"Marketing Planning Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","descriptionBodyPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3","applyUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3/apply"},{"additionalPlain":"About The Team\n\nOur Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media. \n\nAs a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media.&nbsp;</div><div><br></div><div>As a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!</div>","categories":{"commitment":"Internship","department":"HoldCo - Corporate Affairs","location":"Jakarta","team":"Media Intelligence","allLocations":["Jakarta"]},"createdAt":1719818000669,"descriptionPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","description":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","id":"a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","lists":[{"text":"What Will You Do","content":"<li>Monitor corporate news and other related information across channels (print, online, and social media).</li><li>Gather and analyze data from media monitoring to gain insights into public perception of the company and its performance.</li><li>Extract data and present interesting information from findings.</li><li>Identify trends and issues relevant to the company’s needs.</li><li>Collaborate to provide data-driven insights for other teams</li>"},{"text":"What Will You Need","content":"<li>Undergraduate students, preferably from Economics, Business, Computer Science, Marketing, Public Relations or Literature.</li><li>High proficiency in English and Bahasa Indonesia, both written and verbal.</li><li>A critical thinker, observant, and detail-oriented with vast knowledge of current issues and trends.</li><li>High willingness to learn.</li><li>Comfortable handling large data sets.</li><li>Knowledge in Ms Excel.</li><li>A collaborative team member as well as an independent self-starter.</li>"}],"text":"Media Intelligence Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","descriptionBodyPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","applyUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb/apply"},{"additionalPlain":"About The Team\n\nThe management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.\n\nThe AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.</div><div><br></div><div>The AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.</div>","categories":{"commitment":"Permanent","department":"FinTech - AML/CFT","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719311112001,"descriptionPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","description":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","id":"f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","lists":[{"text":"What You Will Do","content":"<li>As an official directly appointed by the relevant Director and responsible for the implementation of AML CFT in the company.</li><li>A pointed person for any Regulatory Compliance matters/projects as well as internal or external auditors in compliance reviews.</li><li>As an industry expert, keep track of the latest developments around regulations and find smart solutions to mitigate ML/TF risks</li><li>Remain knowledgeable of new or changing regulations, regulatory expectations, market conditions, and industry best practices and find smart solutions to mitigate ML/TF risks</li><li>Ensure Subject Matter Experts participate in all activities where expertise is required, including but not limited to, risk assessments, policy writing, training development, advice to the business, monitoring activities, and reporting</li><li>Provide senior management with actionable advice on how to effectively manage AML/CFT-related risks</li><li>Ensure all regulatory reporting requirements related to AML/CFT themes are met</li><li>Ensure implementation AML CFT regular trainings as well to Business Unit and Support Function and to liaise with the Learning &amp; Development PAC;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years in this role in the AML/CFT</li><li>You have extensive knowledge of the payments and or the banking/finance industry</li><li>A thorough understanding of AML/CFT laws and regulations incl. risks, controls, industry best practices and regulatory requirements</li><li>An excellent and direct communicator who talks straight without being rude</li><li>You have the ability to clearly explain AML CFT compliance and related risks, develop sound mitigation strategies, and find workable solutions&nbsp;</li><li>You have extensive experience representing and leading meetings with regulatory agencies, examiners and auditors</li><li>You have the ability to structure and prioritize in a high-volume, fast-paced environment and drive a process to completion</li><li>You are a team player that does not shy away from taking ownership</li>"}],"text":"Merchants AML/CFT Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","descriptionBodyPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","applyUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713245102772,"descriptionPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","description":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","id":"3f4f687f-8599-4d5c-96d5-8af234c3b09d","lists":[{"text":"What You Will Do","content":"<li>Identify and define business opportunities that aligns with the overall merchant services business objectives</li><li>Translate business opportunities into a fit problem statement and able to measure the priority of the problem&nbsp;</li><li>Collaborate with Product Team to develop a merchant focused product in onboarding and support&nbsp;</li><li>Develop Go-To Market plan and oversee the product adoption from funnel conversion rates and merchant experiences during the process.&nbsp;</li><li>Monitoring the product life cycle and continuously improved the product with a data driven decision making process</li><li>Engaged sales and ops team to deliver the best onboarding and support experience for merchants</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of working experience, experience in product and project management is a plus.&nbsp;</li><li>Possess a strong sense of agency in navigating and creating clarity in ambiguous situations.</li><li>Ability to break down complex problems, identify use cases and solutions, and thrive in unstructured environments.</li><li>Comprehensive understanding of data, design, research, and business processes, with the ability to effectively collaborate with diverse teams.</li><li>Strong analytical and quantitative skills, with the capability to utilize data and metrics to support requirements and features.</li><li>Effective communication skills to articulate strategy, insights, priorities, and plans coherently to all levels of management.</li><li>Meticulous attention to detail, with a commitment to upholding high standards and managing multiple, competing priorities concurrently with minimal supervision.</li>"}],"text":"Onboarding & Support Business Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","descriptionBodyPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d","applyUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"Lending Operations","allLocations":["Jakarta"]},"createdAt":1720692666755,"description":"","descriptionPlain":"","id":"0ae5053b-3c5f-432a-9b69-b4cdefb01b79","lists":[{"text":"What You Will Do","content":"<li>Master all Consumer Lending Operations-related data points, including Customer Service, KYC, Telesales, and Transactional Data.</li><li>Manage all Operations Dashboards and Reporting to ensure timely and accurate availability.</li><li>Provide analytical insights leading to actionable plans with positive impacts for stakeholders.</li><li>Support the Head of Operation and other stakeholders in executing operational experimentation and enhancing workflow automation processes.</li><li>Lead, mentor and develop Operation BI team member.</li><li>Assist Operation stakeholders in dealing with Fraud investigation, Campaign Setup, and regulatory reporting and audit preparation</li><li>Analyze, evaluate, and initiate improvements in day-to-day operations for efficiency, effectiveness, and scalability.</li><li>Develop job automation to build Datamart-level tables in Big Query for Operational Dashboard Reporting.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's Degree in Engineering, Mathematics, Statistics, or a related discipline is required.</li><li>5 years of experience in a fast-paced environment, with a background in project management and data analytics.</li><li>Possesses strong analytical, planning, and problem-solving skills.</li><li>Proficient in SQL and Advanced Excel, with a high level of competence in working with numerical data sets. Knowledge of Python and experience in automating tasks is highly advantageous.</li><li>Familiarity with at least one business intelligence tool such as Google Data Studio (Looker), Power BI, or Tableau is preferred.</li><li>Ability to work independently with excellent time management skills, collaborating effectively with cross-functional teams to drive initiatives aligned with organizational objectives and Key Results (OKRs).</li><li>Exceptional communication and interpersonal skills, capable of articulating complex ideas to non-technical stakeholders with clarity and precision.</li><li>Familiarity with data warehousing concepts and methodologies is considered a plus.</li>"},{"text":"About The Team","content":"<li>Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</li><li>Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly. In the coming year, in light of our new GoTo collaboration, we have exciting plans to scale up our team in effort to field the massive growth of our data pool.&nbsp;</li>"}],"text":"Operation Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79","applyUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79/apply"},{"additionalPlain":"Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy & Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs\n","additional":"<div><span style=\"font-size: 10pt\">Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs</span></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720522525041,"descriptionPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","description":"<div><span style=\"font-size: 10pt\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","id":"719f7a78-460a-4496-9298-ca57b835b120","lists":[{"text":"What you will do","content":"<li>Manage operational relationships with Fleet partners</li><li>Gain understanding of the mechanics of Fleet management, and identify pain points</li><li>Provide first level support for Fleet partners to ensure their business can thrive sustainably</li><li>Enhance the dynamic relationships among Gojek, Driver Partners, and Fleet Partners</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 3 years work experience in relevant sectors, e.g. Operations, Process Improvement and Management</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in English and in Bahasa Indonesia</li><li>Strong sense of business and tech processes</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Operation Support Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","descriptionBodyPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120","applyUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120/apply"},{"additionalPlain":"About The Team\n\nThe Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful experience.The Trust & Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and stakeholders.If you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust & Safety team.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful </span><a href=\"http://experience.The\" style=\"font-size: 10pt\" class=\"postings-link\">experience.The</a><span style=\"font-size: 10pt\"> Trust &amp; Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and </span><a href=\"http://stakeholders.If\" style=\"font-size: 10pt\" class=\"postings-link\">stakeholders.If</a><span style=\"font-size: 10pt\"> you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust &amp; Safety team.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1708072107075,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","description":"<div><span style=\"font-size: 16px\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","id":"6f3368c9-6e84-489c-add3-4ad1fd4b9519","lists":[{"text":"What You Will Do","content":"<li>Provide regular analysis and reports on operational performance including compliance, escalations, quality, risk, and KPI tracking to guide decision-making and devise proactive solutions</li><li>Collaborate with cross-functional teams to build, automate, and improve on the availability, integrity, accuracy, and reliability of reporting, data logging, and data pipelines to be secure and compliant</li><li>Liaise with internal and external stakeholders for regulatory and compliance reports whenever needed, including issue investigation and report verification</li><li>Create and maintain performance management dashboards, visualizations, and trackers for Operations</li><li>Develop data-driven business insights and work with cross-functional teams to identify opportunities and implement new product features or system enhancements related to Trust &amp; Safety</li><li>Identify operational weaknesses and opportunities to help improve or innovate new processes and projects to drive user and vehicle quality, customer experience, and compliance to regulatory requirements</li><li>Prepare regulatory compliance reports to ensure adherence to relevant data protection, Insurance, earnings and safety regulations</li><li>Implement and maintain a good data management system to ensure the integrity, confidentiality, and availability of trust and safety-related data.</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in analytics and operations/compliance-related role</li><li>A wizard at working on and analyzing large datasets, with the ability to translate quantitative findings into action plan, demonstrated through understanding of&nbsp; statistical methods and modeling techniques.</li><li>Strong stakeholder and project management capabilities, with great attention to detail</li><li>Resilience and ability to take initiative in our constantly-changing fast-paced environment</li><li>Strong knowledge of SQL, Python, Google Suite, and MS Excel (advanced) is required</li><li>Experience in BI tools such as Tableau, Metabase, or Data Studio is a plus</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Operations Analyst, Data Operations (Trust & Safety)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519","applyUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><span style=\"font-size: 10pt\"><b>About the team </b></span></div><div><br></div><div><span style=\"font-size: 10pt\">At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</span></div>","categories":{"department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721275390563,"descriptionPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","description":"<div><span style=\"font-size: 10pt\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","id":"03e3c5dd-2c14-4737-820e-f32b6cccf632","lists":[{"text":"What you will do:","content":"<li>Monitor and analyze key performance indicators (KPIs) to drive continuous improvement in operations.</li><li>Build and maintain strong relationships with merchant partners, promptly addressing their needs and concerns.</li><li>Train, mentor, and manage a team of onboarding specialists to ensure high performance and professional development.</li><li>Collaborate with internal teams to ensure drivers, merchants, and customers receive exceptional service.</li><li>Stay updated with industry trends and competitor activities to keep GoMart ahead.</li><li>Identify opportunities for operational efficiencies and implement best practices across the team.</li><li>Prepare routine reports and present findings as the basis of rationale and recommendations for strategic decision-making</li><li>Develop and implement strategies to enhance the onboarding process and improve merchant satisfaction.</li>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Strong analytical thinking, insights generating, and complex problem-solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds and ability to manage small team&nbsp;</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written English</li>"}],"text":"Operations Manager - GoMart","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt;\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","descriptionBodyPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","hostedUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632","applyUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632/apply"},{"additionalPlain":"About the team \n\nThe Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721103093996,"descriptionPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","id":"90d1d8b9-75fb-4211-8d69-99412932f5ba","lists":[{"text":"What you will do","content":"<li>Work closely with business and support units to design and execute GoTo Financial payments advocacy.</li><li>Lead external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders to advance GoTo Financial’s mission to provide accessible and safe payment products to all Indonesian users.&nbsp;</li><li>Support Compliance and Regulatory Affairs matters in GoTo Financial&nbsp; Payments Compliance operations, which includes but is not limited to business/product reporting and approval process with the regulators, and technical regulatory assessment</li><li>Create and maintain the latest update of payments regulations databases and provide/disseminate assessment on such regulations to the internal units in GoTo Financial</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law/ Economics/Management/ Accounting and International Relations. Having a master’s degree would be an advantage.</li><li>At least 4 years of mixed experience in the area of public policy/public affairs, and/or regulatory compliance and past working experience in Bank Indonesia/ Otoritas Jasa Keuangan and Public Affairs consulting firms will be an advantage.&nbsp;</li><li>Advanced level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks and proactively choose the best solutions and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including building credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"Payments Compliance PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba","applyUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba/apply"},{"additionalPlain":"\n","additional":"<div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - People & Culture","location":"Jakarta","team":"HR Information Systems","allLocations":["Jakarta","Singapore"]},"createdAt":1718958420176,"descriptionPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","description":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","id":"8fe35112-8410-4cf3-9a50-4c7287e95b57","lists":[{"text":"What You Will Do","content":"<li><b>HRIS Management &amp; Operations: </b>Operate and administer end-to-end Workday as our HRIS platform, serve as technical lead for Workday Core HCM, Talent Management, Absence, and Compensation. Provide technical support on day-to-day HR processes such as operations, payroll, performance management, and merit cycle. Act as a subject matter expert on HRIS-related inquiries and troubleshoot any technical issues that arise.</li><li><b>Process Improvement: </b>Identify opportunities to streamline HR processes using HRIS, automate manual efforts, and increase overall efficiency. Partner with cross-functional teams to identify opportunities for improvement, gather requirements, design, recommend, and implement system-driven solutions.</li><li><b>System Implementation &amp; Integration: </b>Collaborate with partners (HR and IT team) to configure and optimize HRIS modules, workflows, and integrate with other systems such as Payroll, ATS, and Finance to create seamless data flows. Lead HRIS system update and implementation of new HRIS modules, working with vendors and internal teams to plan and execute the process smoothly and successful adoption by stakeholders.</li><li><b>Report Development: </b>Develop and maintain custom reports, dashboards, and visualizations within HRIS to provide insightful HR metrics and analytics to stakeholders.</li><li><b>User Access Management and Compliance: </b>Manage user access and permissions to ensure data security and privacy compliance. Ensure HRIS compliance with relevant data protection and privacy regulations. Monitor and audit HR data to maintain accuracy, quality, and integrity, implementing necessary corrections and preventive solutions.</li><li><b>Training: </b>Provide training to HR staff and end-users on using and familiarities with the HRIS in respective to their roles.</li>"},{"text":"What You Will Need","content":"<li>Proven experience (typically 5+ years) in HRIS management and optimization.</li><li>Strong proficiency with Workday and related HR systems (Lever, Degreed, Larona, etc).Strong understanding of HR processes and workflows, with the ability to translate business requirements into HRIS solutions.</li><li>Excellent project management and problem solving skills, capable of handling multiple initiatives in a fast-paced environment.</li><li>Strong influencing skills with the ability to communicate clearly and confidently with stakeholders.</li><li>Strong managerial and leadership skills with the ability to guide, develop, and mentor team members to make things happen.</li><li>Experience communicating effectively across teams in markets across the region.</li><li><b>Preferred Qualifications: </b>Certification in Workday in one of the following modules: Core HCM, Advanced Compensation, Reporting, Talent, Performance, or Absence Management. Experience in SaaS HR system configuration. Experience with downstream system integrations such as Google Workspace, Google Cloud Platform, Workato, and JIRA/Asana.</li>"}],"text":"People Systems Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","descriptionBodyPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57","applyUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57/apply"},{"additionalPlain":"About The Team\n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div><br></div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721379671434,"descriptionPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","description":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","id":"49388333-1938-4c06-b453-911eee08c53f","lists":[{"text":"What You Will Do","content":"<li>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. </li><li>Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis</li><li>Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</li><li>Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li>"},{"text":"What You Will Need","content":"<li>At least 3 years working experience in an analytical role&nbsp;</li><li>Proficiency in multiple analytic tolls with strong knowledge of SQL and experimentation process</li><li>Effective communication skills with the ability to present financial information clearly and concisely</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Strong business acumen with a data-driven approach to problem-solving and the ability to drive initiatives independently.&nbsp;</li><li>A confident communicator in verbal and written English</li>"}],"text":"Pricing & Supply Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","descriptionBodyPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f","applyUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f/apply"},{"additionalPlain":"Our GoFood Strategy & Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. \n\nThe gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably. \n\nWhen our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">Our GoFood Strategy &amp; Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">The gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">When our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721383021327,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","description":"<div><span style=\"font-size: 9pt\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","id":"0911a6fe-475a-498f-bf48-7d492e3d04d2","lists":[{"text":"What You Will Do","content":"<li><b>Strategize, experiment, and optimize: </b>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact <a href=\"http://analysis.Execute\">analysis.</a></li><li><b><a href=\"http://analysis.Execute\">Execute</a> and collaborate: Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</b></li><li><b>Explore:</b> Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li><div><br></div>"},{"text":"What You Will Need","content":"<li>BS/MS in Business, Engineering, Computer Science, Mathematics, Economics, Statistics, or equivalent experience</li><li>At least 4 years of working experience in an analytical role</li><li>Scientist thinking process that can work in increments and exponents, coupled with hypothesis-driven mindset</li><li>Proficiency in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with strong knowledge of SQL and experimentation process</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><div><br></div>"}],"text":"Pricing & Supply Senior Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2","applyUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2/apply"},{"additionalPlain":"Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714372709159,"descriptionPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","description":"<div><span style=\"font-size: 10pt\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","id":"44117b68-3ece-40ac-91c1-920caadfe5dd","lists":[{"text":"What You Will Do","content":"<li>Design and construct scalable streaming or batch data pipelines to meet various business requirements.</li><li>Establish reliable monitoring and alerting systems to assess data pipeline performance.</li><li>Identify potential bottlenecks in the system and optimize as needed.</li><li>Manage the data science infrastructure to streamline model development and deployment.</li><li>Mentor team members by conducting code reviews and sharing knowledge.</li>"},{"text":"What You Will Need","content":"<li>Experience with streaming processing and Change Data Capture (CDC) tools such as Debezium, Flink, Kafka, etc. is necessary.</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Docker, RDBMS, and NoSQL Databases is desirable.</li><li>Proficiency in Python and SQL is expected.</li><li>Must be self-driven, with a strong sense of ownership, and capable of working independently to solve problems and develop solutions.</li><li>Project management skills to successfully drive large-scale projects from initiation to completion are needed.</li><li>Excellent communication skills, including proficiency in English, are required.</li><li>Understanding of machine learning techniques and algorithms is advantageous.</li>"}],"text":"Principal Data Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","descriptionBodyPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","hostedUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd","applyUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd/apply"},{"additionalPlain":"About the Team - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","additional":"<div><b style=\"font-size: 10pt\">About the Team</b><span style=\"font-size: 10pt\"> - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721188007441,"descriptionPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","description":"<div><span style=\"font-size: 10pt\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","id":"0197001e-f39c-4d55-b6b9-1cf247bd17b0","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutions, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li>At least 8 years of relevant experience</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Principal Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","descriptionBodyPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0","applyUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive. \n\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and </span><a href=\"http://automations.You\" class=\"postings-link\"><span style=\"font-size: 16px\">automations.You</span></a><span style=\"font-size: 16px\"> are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.&nbsp;</span></div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Gurugram"]},"createdAt":1721890257186,"descriptionPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","id":"6f2d563a-182c-4c23-8c72-9d2a4f563ed9","lists":[{"text":"What You Will Do","content":"<li>Improves code structure and architecture in service of testability and maintainability</li><li>Has in-depth understanding of multiple programming languages/paradigms, and highly proficient in one technology area, including how it interacts with the system</li><li>Leads new language/framework POC within a technical focus area, participates in the design review process, and providing constructive criticism for improvement</li><li>Is accountable for the operationalization of the tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Is accountable for ensuring that their squad has strong sets of documentations and journals of how their design and architecture evolves over time</li><li>Ensures predictability, quality &amp; throughput of their squad's delivery</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad's deliveryPrioritizes work based on understanding the trade-off between quality, tech-debt, and delivery</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: significant experience in one or many of the areas including golang/python programming, Events/stream processing framework development, engineering tooling and user facing interfaces, Kubernetes administration</li><div><br></div>"}],"text":"Principal Engineer - Cloud Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px;\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9","applyUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9/apply"},{"additionalPlain":"About the Team :\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div><span style=\"font-size: 11pt\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721116359853,"descriptionPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","id":"7c3c43e3-8b8d-48a4-a590-7754207b2d1b","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, reliable and fault tolerant platforms for one of the world's fastest growing unicorns</li><li>You will be responsible for the overall delivery and the solution architecture of the offerings your team will be working on</li><li>You will own prioritization of initiatives to maximize achievements on objectives and growth for engineering at GoTo</li><li>You should understand product engineering and have empathy with problems and pain points of Product Engineers. &amp; you will continuously contribute to make their experience better</li><li>You shall write code because you like to. You never stop wanting to get better at it</li><li>Communicate, collaborate and work effectively with product teams distributed in a global environment</li><li>You will be responsible for the overall growth, learning and happiness of your team</li><li>Is independently responsible for coaching, development, and career management for the team</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have experience in leading a team of 6-8 engineers and owning the overall delivery for the teams</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Have experience with recruitments and staffing management to help in building a sustainable team</li><li>Can take recruitment and staffing responsibilities depending to balance out the growth</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: Significant experience in one or many of the areas including Clojure programming, Stream processing framework development, engineering tooling and user facing interfaces</li>"}],"text":"Principal Software Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt;\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b","applyUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b/apply"},{"additionalPlain":"About the Team\n\nOur Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1715060912791,"descriptionPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"426f18b4-739e-4da0-a74b-446c349c0a31","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Collaborate with cross functional teams (Mobile, DevOps, UX, QA etc.) on execution and delivery</li><li>Partner with the team to define and execute the feature roadmap</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"What You Will Need","content":"<li>Should have at least 7 years of hands-on experience in designing, developing, testing and deploying applications at scale</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Principal Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31","applyUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719211012411,"description":"","descriptionPlain":"","id":"fc7c3413-6c4f-42bd-a048-70387bd490a4","lists":[{"text":"What you will do:","content":"<li>Process Analysis and Assessment: 1. Conduct comprehensive assessments of existing business processes to identify inefficiencies, bottlenecks, and areas for improvement. 2. Gather and analyze data to understand process performance and identify root causes of issues. 3. Develop process maps, flowcharts, and other documentation to visualize current state processes.</li><li>Improvement Strategy Development: Collaborate with stakeholders to design and develop strategies for process improvement, focusing on enhancing efficiency, quality, and customer satisfaction.</li><li>Implementation of Improvements: 1. Lead cross-functional teams in the implementation of process improvements, ensuring alignment with business goals and objectives. 2. Develop &amp; monitor detailed project plans, timelines, and milestones to guide improvement initiatives.</li><li>Change Management and Communication: Drive change management efforts &amp; communicate effectively to ensure smooth adoption of new processes and practices.</li><li>Performance Monitoring and Reporting: 1. Establish key performance indicators (KPIs) to measure the effectiveness of process improvements. 2. Conduct post-implementation reviews to assess the impact of changes and identify further improvement opportunities.</li><li>Continuous Improvement Culture: Provide mentorship and guidance to stakeholders on process improvement methodologies and tools.</li>"},{"text":"What you will need:","content":"<li>Bachelor's degree in Business Administration, Industrial Engineering, Operations Management, or a related field. A Master's degree is preferred.</li><li>Proven experience in business process improvement, process engineering, or related <a href=\"http://roles.Strong\" class=\"postings-link\">roles.</a></li><li>Strong knowledge of process improvement methodologies (e.g., Lean, Six Sigma, Kaizen).</li><li>Excellent analytical and problem-solving skills.</li><li>Exceptional project management skills, with experience leading cross-functional teams.</li><li>Strong communication and interpersonal skills, with the ability to influence and drive change.</li><li>Proficiency in process mapping and analysis tools (e.g., Visio, Lucidchart).</li><li>Ability to manage multiple projects and priorities in a fast-paced environment.</li>"},{"text":"Preferred Skills:","content":"<li>Fluent in English&nbsp;</li><li>Experience with data analysis tools (e.g., Excel, Tableau, Power BI).</li><li>Knowledge of change management principles and practices.</li><li>Familiarity with ERP and CRM systems, especially Salesforce</li><li>Experience in training and development related to process improvement.</li>"}],"text":"Process Improvement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4","applyUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4/apply"},{"additionalPlain":"About The Team\n\nGoTo Procurement  Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.\n\nAs a team, we are not only concerned about the company but also the professional and personal growth & aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">GoTo Procurement&nbsp; Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we are not only concerned about the company but also the professional and personal growth &amp; aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things</span></div>","categories":{"department":"HoldCo - Finance","location":"Jakarta","team":"Procurement","allLocations":["Jakarta"]},"createdAt":1721729730710,"descriptionPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","id":"c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","lists":[{"text":"What Will You Do","content":"<li>Lead and execute the Vendor Selection process to ensure that the company is getting what it really needs as well as the best deal in the market, following GoTo Procurement Procedure while adhering to relevant Policies and Procedures within the organization and collaborating with the relevant stakeholders and Subject Matter Expert (SME) to support comprehensive evaluation. The vendor selection process will be for both Tactical and Strategic bidding and aim for cost optimization targets and ensure the proper documentation to establish transparency and accountability</li><li>Drive cost optimization initiatives to support organization operating cost optimization through the execution of Procurement activities, including mitigation of any relevant risks within the Source-to-Pay process and supply chain.&nbsp;</li><li>Owning the Source-to-Pay process by ensuring a seamless transition throughout the steps, starting from capturing business needs up to Vendor Payment</li><li>Increase Procurement’s technology and platform utilization and target for SLA optimization and Sourcing Quality</li><li>Develop a Sourcing competencies framework as part of people development within the Procurement Sourcing organization</li><li>Build the right vendor market and network as well as internal stakeholders, to support the collaborations within Procurement processes</li><li>Lead and collaborate Vendor Value Creation Program together with Critical/Valued vendors to deliver innovation, better speed to market, productivity, asset utilization, sustainability, etc.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Bachelors of business, supply chain management, or any other related field. Preferably has been working in Procurement too</li><li>At least 2 years in procurement areas, preferably from multinational companies</li><li>Strong business and commercial mindset</li><li>Excellent negotiation, organizational, and collaboration skills</li><li>Excellent interpersonal and communication skills</li><li>Excellent project management skills</li><li>Advanced in verbal and written English proficiency</li>"}],"text":"Procurement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","descriptionBodyPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","applyUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274/apply"},{"additionalPlain":"About the Team\n\nThe Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.\n\nWe have helped simplify payments for over 750,000 merchant partners, over  1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.</div><div><br></div><div>We have helped simplify payments for over 750,000 merchant partners, over&nbsp; 1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1720599307040,"descriptionPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","description":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","id":"83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","lists":[{"text":"What You Will Do","content":"<li>Conduct merchant research and analyze user data to identify trends and pain points.</li><li>Working with Business Intelligence teams, writing queries and learning to set up product metric tracking dashboards&nbsp;</li><li>Help summarize merchant interviews as insights</li><li>Collaborate with product managers and designers to define product requirements.</li><li>Develop and present product recommendations based on data analysis.</li><li>Assist with creating product prototypes and user testing.</li><li>Stay up-to-date on industry trends and competitor analysis.</li>"},{"text":"What You Will Need","content":"<li>Strong analytical skills with proficiency in data analysis tools, candidates with experience will be preferred</li><li>The ability to write SQL queries is strongly preferred</li><li>Excellent communication and presentation skills.</li><li>A passion for product development and a keen eye for detail.</li><li>Familiarity with the Indonesian payments landscape is a plus.</li>"}],"text":"Product Analyst Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","descriptionBodyPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","applyUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8/apply"},{"additionalPlain":"About The Team\n\nThis vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.  \n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>This vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.&nbsp;&nbsp;</div><div><br></div>","categories":{"department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1718084687109,"descriptionPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","description":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","id":"a1ebb8d4-0af0-4707-9efb-8f52aa781c44","lists":[{"text":"What You Will Do","content":"<li>Help define the roadmap, goals, and vision for the product experience</li><li>Work with design leads, product heads, marketing and engineers to build/improve user experience and ways of working towards that vision</li><li>Manage projects, solve complex problems, and enable your team to deliver delightful solutions that drive impact</li><li>Build systems for design documentation &amp; help establish processes to ensure seamless collaboration</li><li>Mentor and coach a team of designers, improve stakeholders grasp and application of design thinking</li><li>And most importantly, make sure your team is engaged well and building things that make them successful</li>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in product design, but still willing to learn more about product research</li><li>Proficiency in all areas of digital product design; visual design, user experience design, user research prototyping, advocacy and building showcases. Additional exposure to motion, sound, video and other craft are welcome</li><li>Ability to draw insights from both qualitative &amp; quantitative data, and further identify problem areas to work on.</li><li>Ability to design, advocate and prioritize user research with our research team</li><li>Knowledge in design fundamentals, such as design thinking frameworks, HCI principles, and being able to take on a structured approach in solving problems</li><li>Excellent organizational, project management, and collaboration skills to manage a wide range of stakeholders</li>"},{"text":"","content":"<li><br></li>"}],"text":"Product Design Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44","applyUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44/apply"},{"additionalPlain":"About the Team\n\nThe Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. \n\nWe’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers. \n\nThe Loyalty, Incentives & Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more. \n\nWe are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .\n\n\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. </div><div><br></div><div>We’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers.&nbsp;</div><div><br></div><div>The Loyalty, Incentives &amp; Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more.&nbsp;</div><div><br></div><div>We are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .</div><div><br></div><div><br></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718798053606,"descriptionPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","id":"e407433b-435a-4607-89bd-5faf51cf622e","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of a senior product designer, and follow the predefined process set forth by the team</li><li>Able to comprehend the product briefs and be able to present the ideas/solutions to the team under the supervision of the product design lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Define end-to-end wireframe and wireflow for features using standard wireframing tools</li><li>Document the design process for each feature, such as research findings, ideations, usability tests, release, and monitor the impact after the product release</li><li>Contribute to the team cadence discussion and make occasional short presentations to the team, as well as present team’s updates if needed</li><li>Proactively seek/give feedback from other stakeholders to make sure concepts are meeting the intended project goal</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of relevant experience in the product design industry</li><li>Familiar with data and can identify problem areas, further map out the user journey, and break the problems into smaller chunks</li><li>Use basic analytics tools to gather customer data (funnel)&nbsp;</li><li>Possess a good knowledge of design fundamentals, such as design thinking framework and other frameworks to develop products</li><li>Able to sketch the ideas into wireframes, learn how to make wireflow, and do wireframing for well-defined features</li><li>Good knowledge of the tools, such as Overflow, Miro, Sketch, Figma, or similar ones that are widely used by Product Designers</li><li>Knowledge of design validation, either through quantitative or qualitative research</li><li>Preferably some knowledge of service design and experience with working on mobile app design</li>"}],"text":"Product Designer - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e","applyUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e/apply"},{"additionalPlain":"About The Team\n\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718166115141,"descriptionPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","description":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","id":"b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirements and the impact of each feature, as well as the go-to-market strategy to ensure adoption of the features</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in product management experience</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Growth","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","applyUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba/apply"},{"additionalPlain":"About The Team\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. \n\nThe Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.\n","additional":"<div><b>About The Team</b></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology.&nbsp;</div><div><br></div><div>The Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.</div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719305116114,"descriptionPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","id":"6f05ee4a-fa49-4aca-8990-c6607cd7cf09","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched&nbsp;</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirement and the impact of each feature as well as the go to market strategy to ensure adoption of the features.&nbsp;</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of total experience, with 2-3 years experience specifically in product management</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09","applyUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09/apply"},{"additionalPlain":"About The Team\nWork hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Work hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721026583842,"descriptionPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","id":"92f4b266-849a-42f2-b7e0-859360a003d8","lists":[{"text":"What You Will Do","content":"<li>Develop and own end-to-end project and program plans that outline scope, goals, deliverables, required resources, and timelines&nbsp;</li><li>Monitor progress of projects and programs to highlight plan deviations,, resolve issues and propose corrective actions to remove implementation blockers</li><li>Oversee and synergise multiple projects to ensure prompt completion within scope, and within budget</li><li>Work closely with internal and external stakeholders from cross-functional teams to assess feasibility of initiatives, develop the scope, and deliverables</li><li>Act as a point of escalation for project and program initiatives’ issues, mediate issues, and ensure stakeholder’s expectations are met</li>"},{"text":"What This Role Needs","content":"<li>At least 3 years of work experience in the financial industry, having worked in mid to large-scale cross-functional projects and/or programs, particularly in lending (consumer and/or loan lending products, such as cash loan, buy now pay later, merchant financing, vehicle financing, etc)</li><li>Well-versed in speaking &amp; writing in English, Bahasa Indonesia; Mandarin is a plus</li><li>Comfortable in fronting conversations with senior leaders and C-suite leaders</li><li>Able to work under pressure with strict implementation timelines</li><li>Possess a strong ability to analyze data and generate insights to value-add to the projects/programs</li><div><b>Soft Skills</b></div><li>Stakeholder management skills</li><li>Sharp business acumen</li><li>Attention to details</li><li>Time management</li><div><b>Hard Skills</b></div><li>Project / ProgramManagement Skills, ideally CAPM certified will be advantageous</li><li>Six Sigma Skills, ideally Six Sigma GreenBeltcertified will be advantageous</li><li>Knowledgeable about financial industry laws &amp; regulations &amp; being compliant at all times</li><li>Good working knowledge of Project Management tools like Jira, Lark and Google Suites</li><li>Knowledge about e-commerce / transport industries is a plus</li>"}],"text":"Program Manager, Consumer Lending - #10310","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","descriptionBodyPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8","applyUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8/apply"},{"additionalPlain":"About the Team\n\nOur Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720752364065,"descriptionPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","id":"20554643-fae8-4082-8797-7d5fd44db8b0","lists":[{"text":"What You Will Do","content":"<li>Develop and run complex analysist to support business decision</li><li>Design and develop dashboards to track business and product performance</li><li>Leverage data from dashboards as well as other sources to derive insights as a basis of rationale and recommendations in decision-making processes</li><li>Running a project management for multiple projects at different stages &amp; complexity</li>"},{"text":"What You Will Need","content":"<li>At least 2-3 years of experience in a business analytics or business intelligence role at a tech company</li><li>End-to-end the problem-solving mindset</li><li>Strong communication and project management skills</li><li>Strong proficiency in SQL, Microsoft Excel, and PowerPoint</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"Project Manager - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0","applyUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0/apply"},{"additionalPlain":"About the Team\n\nInsurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721362323598,"descriptionPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","id":"8906c3d0-c77f-4a0a-8f25-8b738515ede3","lists":[{"text":"What You Will Do","content":"<li>Attend daily standup meetings, sprint planning, and backlog reviews</li><li>Communicate project status to internal and external teams promptly</li><li>Analyze and estimate product features from a testing perspective</li><li>Ensure software quality by adopting best practices in software development</li><li>Design, develop, and execute automation scripts using open-source tools</li><li>Identify, record, document, and track bugs thoroughly</li><li>Perform thorough regression testing when bugs are resolved</li><li>Collaborate with product managers to clarify feature requirements and ensure comprehensive test coverage</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of experience in professional testing</li><li>Strong understanding of unit testing concepts and problem-solving using online resources</li><li>Deep knowledge of Manual &amp; Automation test methodologies and principles</li><li>Capability to create testing scenarios/scripts using test management tools</li><li>Experience in Mobile and API Testing in both manual &amp; automation contexts</li><li>Proficiency with automation tools like Jira, Selenium, RestAssured, ​​TestNg using Java (preferably), Postman, Gitlab, Kafka</li><li>Good understanding of logging mechanisms, messaging services, and pipelines</li><li>Experience working with the AGILE process methodology and strong interpersonal communication skills for collaboration with remote teams</li>"}],"text":"QA Engineer - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3","applyUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717052781419,"descriptionPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","description":"<div><span style=\"font-size: 10.5pt\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","id":"4ba1eea8-feed-4843-be2e-93a21f0eadb1","lists":[{"text":"What Will You Do","content":"<li>Perform exploratory data analysis using SQL and present interesting findings to business stakeholders to drive business and strategic decisions</li><li>Design and analyze experiments to improve service quality and quantity</li><li>Build and maintain self-serve data products such as dashboards (Looker &amp; Tableau) and tables to reduce time to insights</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Should have at least 2-3 years of practical experience in <a href=\"http://SQL.Prior\" class=\"postings-link\">SQL.</a></li><li><a href=\"http://SQL.Prior\" class=\"postings-link\">Prior</a> experience with applied statistics, experimental design is a <a href=\"http://plus.Able\" class=\"postings-link\">plus.</a></li><li><a href=\"http://plus.Able\" class=\"postings-link\">Able</a> to tell a coherent data narrative using visualization tools and able to set best practices in data visualization to convey a product insight through impactful <a href=\"http://graphs.Proven\" class=\"postings-link\">graphs.</a></li><li><a href=\"http://graphs.Proven\" class=\"postings-link\">Proven</a> ability to recognize business needs and ability to communicate with multiple stakeholders including PMs, business and <a href=\"http://operations.Balance\" class=\"postings-link\">operations.</a></li><li><a href=\"http://operations.Balance\" class=\"postings-link\">Balance</a> attention to detail with swift execution.</li><div><br></div>"}],"text":"Region Analytics Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","descriptionBodyPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1","applyUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1/apply"},{"additionalPlain":"About The Team\n\nAs an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">As an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713428751727,"descriptionPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","description":"<div><b style=\"font-size: 10pt\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","id":"0489939a-c571-4d5f-adaa-95ceac8912c5","lists":[{"text":"What You Will Do: ","content":"<li>Responsible for completed orders and profit and loss target achievement</li><li>Provide analytics to support operations team such as Supply Reliability, Fraud rules, Driver’s Engagement etc. at the regional level</li><li>Deploy defined strategies from operations perspective during the process of establishing the new area of service as well as optimizing existing area</li><li>Ensure SOP and legal compliances in the region</li><li>Support Regional Operation Head to oversee all districts and branches operations</li><li>Analyze driver states &amp; measure efficiency of various driver badges to generate more high quality drivers in the region</li><li>Support Regional Operation Head in product changes roll out in the region</li>"},{"text":"What You Will Need:","content":"<li>Having at least 5 years experience in supply chain, preferably at the managerial level and from Multi National Company or similar experience in the Ride Hailing/ On Demand Service Industry</li><li>Strong analytical thinking and problem solving skills using various improvement tools and methods (preferably have prior exposure to SQL)</li><li>Having good understanding about supply and demand planning</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Lead team / project as well as persuade stakeholders to ensure speed &amp; quality of project / initiative</li><li>Proficiency in to converse in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Region Operations Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","descriptionBodyPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5","applyUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718002291914,"descriptionPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","description":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","id":"f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","lists":[{"text":"What You Will Do","content":"<li>Monitor and analyze transactions and user activities to detect suspicious patterns and potential fraud.</li><li>Conduct thorough investigations of suspected fraud cases and recommend control actions.</li><li>Develop and implement strategies to mitigate fraud risks across the platform.</li><li>Collaborate with product, engineering, and operations teams to enhance fraud prevention measures.</li><li>Prepare detailed reports on fraud incidents, including root cause analysis and actionable recommendations.</li><li>Provide regular updates to senior management on fraud trends, risks, and mitigation efforts.</li><li>Stay updated on the latest fraud trends, tools, and best practices to continuously improve detection and prevention strategies.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Finance, Accounting, Business, Computer Science, or a related field.</li><li>2+ years of experience in fraud risk management or a related role.</li><li>Strong analytical and problem-solving skills, with proficiency in data analysis tools (e.g. SQL, Python, Excel) and experience with visualization tools (e.g. Tableau, DataStudio)</li><li>Excellent communication and interpersonal skills.</li><li>Ability to work independently and as part of a team in a fast-paced environment.</li><li>Strong attention to detail and commitment to accuracy.</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Risk Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","descriptionBodyPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","applyUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710738954272,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"60d37414-287e-4552-a0d0-accf1737d0ce","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>3-4 years of related payment risk experience, preferably on the acquiring side and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business side</li>"}],"text":"Risk Analyst - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce","applyUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce/apply"},{"additionalPlain":"In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1704856901936,"description":"","descriptionPlain":"","id":"5611e062-e094-4da3-ab1c-75c85cf62194","lists":[{"text":"What You Will Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volumes of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutions, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers&nbsp;</li>"},{"text":"What you will need","content":"<li>3+ years of experience developing ML solutions</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Risk Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194","applyUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713334327811,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"a61cda6c-82fd-4daf-aabf-3db91e01684f","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>5-8 years of related payment risk experience, preferably on the mobile apps and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business sid</li>"}],"text":"Risk Manager - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f","applyUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715584452832,"descriptionPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","description":"<div><b style=\"font-size: 16px\">About the team:</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","id":"d6ac496c-e0ad-4669-b594-ede9bf8d55f9","lists":[{"text":"What you will do:","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed,</li><li>Resolve account issues and complaints,</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis,</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments,</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation,</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients,</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms.</li>"},{"text":"What you will need:","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area,</li><li>A minimum of 3 years of experience in business management, sales, or project management is mandatory. </li><li>Prior experience in e-commerce and managing key accounts will be a plus point,</li><li>Fluency in both Bahasa and English is required,Able to multitask, prioritize, and manage time efficiently,</li><li>Ability to negotiate, persuade and influence others,</li><li>Excellent interpersonal, communication, presentation and analytical skills,</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills,</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners.</li>"}],"text":"Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the team:</b></div><div><span style=\"font-size: 16px;\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","descriptionBodyPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9","applyUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9/apply"},{"additionalPlain":"The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood campaigns.\n\nIn the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales team.When our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their efficiency.\n\nIn our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood </span><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">campaigns.</span></a></div><div><br></div><div><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales </span><a href=\"http://team.When\" class=\"postings-link\"><span style=\"font-size: 10pt\">team.When</span></a><span style=\"font-size: 10pt\"> our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their </span><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">efficiency.</span></a></div><div><br></div><div><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Excellence","allLocations":["Jakarta"]},"createdAt":1714365620212,"descriptionPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","description":"<div><span style=\"font-size: 10pt\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","id":"f39be622-e287-41df-bcb2-7389478a1be4","lists":[{"text":"What you will do","content":"<li>Oversee the performance tracking and monitoring of the whole Enterprise Sales Team</li><li>Ensure that the Enterprise Sales team has all the data they need to achieve their target for all KRs</li><li>Act as a consultant and discuss with the EKAMs on the business needs/challenges that their merchants are facing</li><li>Provide data and data driven insights to EKAMs to help address said challenges</li><li>Assist in performing periodical business analysis, tailored to each merchant based on their business needs</li><li>Assist in the daily tasks and smooth operations of Enterprise Sales Support</li><li>Liaise with HO team for merchant x sales account management, target, tracker, etc</li><li>Liaise with other teams (e.g. BI, Salestech) when there is new KRs / data point that needs to be analysed</li><div><br></div>"},{"text":"What you will need","content":"<li>At least 2 years of relevant experience in data analytics&nbsp;</li><li>Good business acumen, able to develop analysis with good storyline and flow</li><li>Proficient in SQL, Google BigQuery and the reporting thereof is an advantage</li><li>Proficient in handling large amount of data using tools/softwares such as google sheet, metabase and datastudio</li><li>Great communication and understanding skill, able to explain technical terms in simple, understandable manner</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>High interest and eagerness to analyse different parts of businesses to help achieve growth</li><li>Clear understanding of Gojek services and the tech industry</li><div><br></div>"}],"text":"Sales Support Senior Associate, Enterprise","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","descriptionBodyPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4","applyUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4/apply"},{"additionalPlain":"About The Team\n\nOur Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1720004794044,"descriptionPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","id":"bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","lists":[{"text":"What You Will Do","content":"<li>Identify areas of business growth by structuring problem statements and forming hypotheses</li><li>Query and process large amounts &amp; complex data sets of our customers’ behavior, usage patterns, statistical trends, and funnel performance&nbsp;&nbsp;</li><li>Synthesize actionable insights and solutions from the data analysis</li><li>Own and drive the proposed initiatives to achieve business objectives</li><li>Visualize and communicate findings in an easy-to-understand, concise, and clear format</li><li>Experiment with the growth initiatives and continuously iterate to find areas for improvements</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience working in a data-driven environment, previous experience in the tech industry is a bonus</li><li>Proficient in data query, data processing, and charting to synthesize actionable insights from large sets of complex data</li><li>Strong structured problem-solving abilities to identify issues, form hypotheses, and generate recommendations</li><li>Ability to create and execute experimentation plans or A/B testing on key growth initiatives&nbsp;</li><li>Excellent project and stakeholder management skills to ensure all planned initiatives are met on high quality and on time</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Ability to learn new things and adapt your priorities quickly within a fast-paced environment</li>"}],"text":"Savings Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","descriptionBodyPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","applyUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1698657930091,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"376aefd9-6d6c-4e57-8040-a3b0dd416d26","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2 to 4 years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26","applyUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719471574933,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2-4+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","applyUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Consumer Experience","allLocations":["Bengaluru"]},"createdAt":1716277072995,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"0169bd4d-f352-4162-8e8e-2c09df5b8db4","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Growth","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4","applyUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788743352,"descriptionPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","id":"08aa1472-d91f-4c5d-b5e0-e88163943bcd","lists":[{"text":"What You Will Do","content":"<li>Design, implement, and maintain the company’s IT infrastructure, ensuring scalability, reliability, and performance.</li><li>Manage servers, networks, databases, and cloud services to support business operations and growth.</li><li>Develop and implement comprehensive cybersecurity strategies to protect the company’s assets and data.</li><li>Conduct regular security assessments, vulnerability scans, and penetration testing to identify and mitigate risks.</li><li>Oversee the installation, configuration, and maintenance of hardware and software systems.</li><li>Ensure data integrity and availability through effective backup and disaster recovery planning.</li><li>Develop and enforce IT policies and procedures to ensure security, compliance, and efficient operations.</li><li>Ensure compliance with relevant regulations and industry standards.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, Information Technology, or a related field. A Master’s degree or relevant certifications (e.g., CISSP, CISM) is a plus.</li><li>Minimum of 7 years of experience in IT infrastructure management, cybersecurity, or a related role, with at least 3 years in a leadership position, preferably in the cryptocurrency or fintech industry.</li><li>Strong understanding of IT infrastructure, network administration, and cybersecurity practices.</li><li>Proven track record of developing and implementing successful IT and security strategies.</li><li>Excellent analytical, problem-solving, and organizational skills.</li><li>Strong leadership, communication, and interpersonal skills.</li><li>Preference qualifications in high-frequency trading</li>"}],"text":"Security and System Infra Manager (CISSP) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd","applyUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd/apply"},{"additionalPlain":"About the Team\n\nThe Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial <a href=\"http://platforms.It\" class=\"postings-link\">platforms.It</a> is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719832381686,"descriptionPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","id":"9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","lists":[{"text":"What You Will Do","content":"<li>Perform security design on applications (web, mobile) and infrastructures (cloud, on-premise)</li><li>Perform security code review (manual, automated) on applications and infrastructures</li><li>Ensure applications and infrastructures are secure by design, follow secure design principles, and adopt secure coding practices</li><li>Identify security gaps and vulnerabilities, and propose appropriate controls and remediations</li><li>Propose solutions to wide-ranging security problems</li><li>Raise security awareness among the Product, Engineering, and Infrastructure team by conducting security training, and having regular security discussions</li><li>Bridge communication between the broader Information Security team with the Product, Engineering, and Infrastructure team</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, or a related field</li><li>Minimum 3 years of experience in Software Engineering, preferably on web and mobile application</li><li>Minimum 3 years of experience in Information Security, preferably in application and cloud security</li><li>Good knowledge of common secure design principles and secure coding practices</li><li>Good knowledge of common adversarial techniques, tactics, and procedures&nbsp;</li><li>Ability to learn new things quickly and independently</li><li>Ability to communicate effectively, preferably in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Security Engineering Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","descriptionBodyPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","applyUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12/apply"},{"additionalPlain":"About the Team \n\nMxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).\n\nCore areas that we focus on - \nDeveloper Experience and Tooling: We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.\n\nFoundation and Building Blocks: This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!\n\nApp Excellence and Insights Tooling: The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">MxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).</span></div><div><br></div><div><b style=\"font-size: 16px\">Core areas that we focus on - </b></div><div><b style=\"font-size: 16px\">Developer Experience and Tooling: </b><span style=\"font-size: 16px\">We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.</span></div><div><br></div><div><b style=\"font-size: 16px\">Foundation and Building Blocks:</b><span style=\"font-size: 16px\"> This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!</span></div><div><br></div><div><b style=\"font-size: 16px\">App Excellence and Insights Tooling: </b><span style=\"font-size: 16px\">The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697010103248,"descriptionPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","id":"3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","lists":[{"text":"What You Will Do ","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need ","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Android Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px;\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","applyUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b/apply"},{"additionalPlain":"About the Team\n\nThe Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.\n\nCTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.</div><div><br></div><div>CTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721369663762,"descriptionPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","id":"767d8980-5402-488d-b62c-222c0b4a0bfc","lists":[{"text":"What You Will Do","content":"<li><b>Observe</b>: Monitor the surface, deep, darkweb, and listen to your intelligence-sharing circles.</li><li><b>Analyze</b>: Through understanding of the internal landscape assess the (predicted threat). Support the incident response investigation, when needed.</li><li><b>Disrupt</b>: disrupt the effectiveness of the threats by various means.</li><li><b>Report</b>: Communicate timely, simply, and effectively the threat and key recommendations.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, Networking, and Cyber Security.</li><li>Working experience with one or multiple categories of tools (open source or commercial): Link Analysis Tools, Threat Modeling Tools, (Threat) Feed Aggregators, Threat Intelligence Platforms (TIP’s), Digital Risk Protection platforms, Malware Sandboxes, SOAR, SIEM or EDR.</li><li>5-7 Years of working experience (strong mid-level or senior in cyber security), relevant degree (bachelor or higher), or reputable industry certification (e.g.: ISC2, GIAC, Offsec, EC Council) preferred.</li><li>Extensive working experience in the CTI field is preferred, candidates from the following affiliated fields are alternatively also preferred: SOC, Vulnerability Management (VAPT), Penetration Testing, or Digital Forensics Incident Response (DFIR).</li><li>Possess critical thinking and problem-solving skills.</li><li>Leadership, experience in mentoring junior members, and stakeholder management skills are a must. You will be leading multiple important initiatives across the teams/companies.</li><li>Proficiency in English and Indonesian, both in written and oral form.</li><li>Outstanding reporting skills: content, delivery, clarity, brevity, and presentation.</li>"}],"text":"Senior Cyber Threat Intelligence Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt;\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","descriptionBodyPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc","applyUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719213882004,"descriptionPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","description":"<div><b style=\"font-size: 10pt\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","id":"1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","lists":[{"text":"What you will do","content":"<li><b>Design, build, and maintain the ETL </b>from various sources into the data mart; Troubleshoot and resolve data-related issues, including data discrepancies, anomalies, and performance bottlenecks</li><li>End to end data project ownership and collaboration with cross-functional teams to understand data requirements and design data models that support the organization's single version of truth</li><li>Ensure the quality, accuracy, and reliability of our data by implementing data validation checks and error handling mechanisms</li><li>Develop and customize Tableau/Google Sheet/Looker studio reports that provide actionable insights to stakeholders</li><li>Create and maintain documentation related to data structures, processes, and transformations for future reference</li>"},{"text":"What you will need","content":"<li>4 years of experience in <b>Data Analyst/BI Analyst/</b>BI Engineer</li><li>Advance knowledge of <b>SQL </b>and Python</li><li>Able to lead a small team also can work as a individual contributor</li><li>Hands on experience with data visualization Tableau Looker studio/Google Sheet</li><li>Strong analytical and problem-solving skills, with keen attention to detail</li><li>Excellent communication skills (English is a must) to collaborate with technical and non-technical stakeholders</li><li>Having a people manager experience is a plus</li>"}],"text":"Senior Data Analyst (Analytics Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","descriptionBodyPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","applyUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264696268,"descriptionPlain":"\n","description":"<div><br></div>","id":"6d8ebb73-2348-423d-847e-b8a8408ac1ed","lists":[{"text":"What You Will Do","content":"<li>Gather business requirements to support BI projects.</li><li>Explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What you will need ","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Senior Data Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed","applyUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed/apply"},{"additionalPlain":"Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719472943608,"descriptionPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","description":"<div><span style=\"font-size: 10pt\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","id":"90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","lists":[{"text":"What You Will Do","content":"<li>Design, build, and maintain data streaming solutions.</li><li>Troubleshoot and resolve data-related issues, including discrepancies, anomalies, and performance bottlenecks.</li><li>Ensure scalability and reliability of the data streaming platform.</li><li>Collaborate with data engineers, data scientists, and other stakeholders to understand requirements and provide tailored streaming solutions.</li><li>Monitor and optimise performance to ensure low latency and high throughput.</li><li>Perform regular maintenance tasks, including upgrades and patches.</li><li>Document design, implementation, and maintenance processes.</li><li>Stay updated with the latest advancements in data streaming technologies.</li>"},{"text":"What You Will Need","content":"<li>3 - 6 years of experience as a Data Engineer.</li><li>Strong programming skills in Java.</li><li>Hands-on experience in real-time streaming with Apache Flink.</li><li>Experience working with Apache Kafka and Kubernetes.</li><li>Experience working with any cloud platform and NoSQL database.</li><li>Strong analytical and problem-solving skills, with keen attention to detail.</li><li>Excellent communication skills for collaborating with technical and non-technical stakeholders.</li><li><b>Good to have: </b>Programming in Go/Python, IAC using Terraform, Batching ETL and exposure to open data lakehouse architecture is a plus</li><li><br></li>"}],"text":"Senior Data Engineer - Data Streaming","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","descriptionBodyPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","applyUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720774001435,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"976d0171-5a06-43e2-9ec6-e0b45345c6fd","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd","applyUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd/apply"},{"additionalPlain":"About The Team\nThe GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><span style=\"font-size: 10pt\">The GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1684915963454,"descriptionPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","description":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","id":"a539cdc1-109f-48e8-9b24-1a831b735f01","lists":[{"text":"What Will You Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volume of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers</li>"},{"text":"What You Will Need","content":"<li>6+ years of experience developing ML solutions, 2-3 years of <b>fraud risk experience in account takeover, scam, and abuse</b></li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt;\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","descriptionBodyPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01","applyUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1713852044349,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"34f6146a-c482-407c-a31c-72ac9bb90a7c","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>Analyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist - Marketplace (Singapore)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c","applyUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1705993404249,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"86673189-b5e2-4ace-b1a3-5ab20f14d84d","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist (India)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d","applyUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707210044551,"descriptionPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","description":"<div><span style=\"font-size: 10pt\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","id":"c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","lists":[{"text":"What You Will Do","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What You Will Need","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li>"}],"text":"Senior Data Warehouse Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","descriptionBodyPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","applyUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69/apply"},{"additionalPlain":"About The Team\n\nOur Data Warehouse team is based in Jakarta & Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nOur team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data Warehouse team is based in Jakarta &amp; Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1713498805305,"descriptionPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","description":"<div><span style=\"font-size: 10pt\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","id":"2b430ba4-210e-4db6-a63e-c11459a0304f","lists":[{"text":"What Will You Do?","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What Do You Need? ","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li><li>You’re passionate about your customers and always bring questions back to what will serve them best</li>"}],"text":"Senior Data Warehouse Engineer - India","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt;\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","descriptionBodyPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f","applyUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f/apply"},{"additionalPlain":"About the Team\n\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719199384298,"descriptionPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"905d4e32-1699-4fcc-96b3-aa6aa0b462cb","lists":[{"text":"What You Will Do","content":"<li>Analyze database performance data to identify bottlenecks and implement optimizations to enhance system efficiency and reliability</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li><li>Design and develop custom tools and utilities to facilitate various database operations, leveraging programming languages such as Ruby, or Golang</li><li>Ensure database security best practices are implemented and maintained, including access control, encryption, and compliance with relevant regulations</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Continuously evaluate database infrastructure usage and performance metrics to identify opportunities for cost optimization</li><li>Benchmarking tests to evaluate the impact of configuration changes on database performance. This helps in identifying optimal parameter values and fine-tuning configurations for different types of workloads.</li><li>Tuning database configuration parameters to optimize database performance for the application</li>"},{"text":"What You Will Need","content":"<li>8+ years experience as a DBA Engineer in managing databases for a large production environment</li><li>Expert in various database management systems (MySQL/PostgreSQL, Redis, MongoDB, and Elastic Search), and techniques for optimizing databases and understanding the basic cloud platform (AWS or GCP)</li><li>Advanced skills in a programming language like Ruby or Golang, and possess deep expertise in shell scripting</li><li>Excellent experience with Linux is required and expertise in server configuration, maintenance, and troubleshooting</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)</li><li>Proficient in seamlessly conducting database upgrades, ensuring uninterrupted operations and system integrity.</li><li>Proficiency in configuring and utilizing monitoring and diagnostic tools to pinpoint and address database performance issues effectively</li><li>In-depth knowledge of the various configuration parameters tailored to the specific database management system</li>"}],"text":"Senior Database Administrator Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb","applyUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb/apply"},{"additionalPlain":"About the Team\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719198420770,"descriptionPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"28fe323b-ed5f-482b-b71d-ed60662bed8b","lists":[{"text":"What You Will Do","content":"<li>Develop automation scripts and tools for provisioning, deployment, monitoring, and backup/recovery of databases using infrastructure as code (IaC) principles</li><li>Implement robust monitoring and alerting systems for database performance metrics&nbsp;</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Maintain version-controlled configurations for database servers, ensuring consistency and repeatability across environments via IaC</li><li>Automate routine tasks such as database backups, schema migrations, and data archiving to improve operational efficiency</li><li>Develop database high availability and replication solutions to meet the requirements of critical applications.</li><li>Develop standardized operational procedures within the DBaaS framework to ensure the consistent provision of highly available solutions.</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li>"},{"text":"What You Will Need","content":"<li>5+ years Experience as a DevOps Engineer with a focus on database management</li><li>Hands-on experience with cloud platforms (AWS or GCP)</li><li>Proficiency in scripting languages such as Go, Shell, and Ruby for automation tasks</li><li>Experience with infrastructure as code tools (e.g., Terraform, CloudFormation) for provisioning and managing database resources</li><li>In-depth knowledge of database systems such as MySQL, PostgreSQL, MongoDB, etc., including configuration, optimization, and troubleshooting</li><li>Strong understanding of CI/CD practices and tools</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)&nbsp;</li><li>Experience in configuration management tools (eg: ansible) for database patching and maintenance automation</li>"}],"text":"Senior DevOps Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b","applyUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1706508052225,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","id":"da8d4a37-f5a4-4436-8743-58c787781285","lists":[{"text":"What You Will Do","content":"<li>Take ownership of one of OKR related to demand and growth that leads to revenue and profitability from one of Gojek product’ business; defines the strategy and roadmap for the team to achieve it by combining multiple initiatives (e.g., content/communication, vouchers/promotion, product changes)</li><li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Build predictive model or clustering model to allocate the promo allocation efficiently</li><li>Run multiple experiments to validate hypothesis in fast pace iteration cycle</li><li>Drives the team for prioritization, strategy, and focus on solutions to solve user problems</li><li>Introduce beneficial business changes through well-written strategy documents and validate the strategy and hypotheses through robust experimentation and statistical approach</li><li>Optimize and automate solutions by leveraging Data Sciences resources</li><li>Perform feedback loop and retroactive analysis of the team performance and operation to evaluate and improve their impact on Gojek’'s North Star Metrics</li><li>Proactively review the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Present findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis.</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 5 years of working experience with a minimum of 1-2 year of leadership experience</li><li>Proficiency in data analysis tools and programming languages such as Python, R, SQL, and data visualization tools like Tableau or Power BI. Strong analytical skills to interpret complex data sets and extract actionable insights</li><li>High proficiency in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficiency in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Understanding of business operations, strategies, and objectives. The Consumer Analytics Lead should be able to connect analytical insights to business goals and contribute to overall decision-making</li><li>Data Management: Familiarity with data collection, storage, and management best practices</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Experience in a SaaS, Marketplace, Food Delivery, or other technology company is a plus</li>"}],"text":"Senior Growth Manager - Food & Ads","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285","applyUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285/apply"},{"additionalPlain":"About The Team\n\nThe mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.\n\nThe Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.\n\nIn addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.</div><div><br></div><div>The Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.</div><div><br></div><div>In addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.</div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Jakarta","team":"-","allLocations":["Jakarta","Bengaluru"]},"createdAt":1721729849780,"descriptionPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","description":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","id":"e6583aa0-7097-4e6f-9f91-7f24d5441156","lists":[{"text":"What You Will Do","content":"<li>Develop and communicate a clear product vision and roadmap for data science/GenAI platforms/products, and Streaming/Batching Pipeline products.</li><li>Lead the end-to-end product development lifecycle from ideation through launch and iteration, aligning product strategies with business objectives and stakeholder needs.</li><li>Collaborate closely with cross-functional teams, including engineering, data science, analytics, and operations, to deliver high-quality products.</li><li>Prioritize features and improvements based on data analysis, user feedback, and business impact.</li><li>Utilize data-driven insights to inform product decisions and measure the impact of product features.</li><li>Implement and track key performance indicators (KPIs) to ensure product success and drive continuous improvement.</li><li>Foster a culture of experimentation and iteration to optimize product performance and user satisfaction.</li><li>Communicate product updates, progress, and challenges effectively to stakeholders at all levels of the organization.</li>"},{"text":"What You Will Need","content":"<li>5+ years of product management experience, specializing for at least 3 years in data science platforms, data pipelines, or related products.</li><li>Proven track record of successfully managing complex technical products in fast-paced environments.</li><li>Strong understanding of data science, and data engineering principles.</li><li>Experience with streaming and batching data processing technologies such as Apache Kafka, Spark, Flink, etc will be a big plus.</li><li>Strong analytical and problem-solving skills, leveraging a data-driven approach to decision-making.</li><li>Excellent verbal and written communication skills.</li><li>Demonstrated leadership abilities, capable of inspiring and motivating cross-functional teams.</li>"}],"text":"Senior Product Manager, Data Science Platform and Data Products","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156","applyUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156/apply"},{"additionalPlain":"About The Team\n\nOur Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. </div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1717126992883,"descriptionPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","id":"50c8a826-2076-40a3-a829-b96b29c9647f","lists":[{"text":"What You Will Do","content":"<li>Conduct research to understand merchants needs and behavior and analyze product performance data to identify opportunities&nbsp;</li><li>Developing and executing a data-driven marketing strategy that aligns with the overall business objectives</li><li>Create product positioning and messaging to differentiate our products from competitors</li><li>Creating and managing marketing campaigns across various channels, including search, social media, and email marketing by working together with both internal and external stakeholders to deliver the plan</li><li>Developing and managing referral or other marketing programs to drive merchant acquisition</li><li>Identify, develop, implement, and refine consumer-focused lifecycle &amp; retention marketing strategies</li><li>Continuously monitor and analyze data to create campaign or marketing reports</li><li>Running A/B tests and analyzing results to optimize conversion rates and user acquisition.</li>"},{"text":"What You Will Need","content":"<li>3+ years working experience in Tech, Bank, Consulting or Marketing Agencies</li><li>2+ years experience in marketing or growth roles</li><li>Customer obsession and passionate in marketing</li><li>Strong analytical skills, data-driven and delighted with statistical analysis and figures</li><li>Strong communication skills, collaborative spirit, delighted to work with other stakeholders (BI/Data, Business, Product, Leadership)</li><li>Strong business sense and problem-solving skills</li>"}],"text":"Senior Product Marketing Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f","applyUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f/apply"},{"additionalPlain":"About The Team\n\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1722243132222,"descriptionPlain":"About The Role\n\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","id":"afd9e752-82f0-4b4f-a4ef-5d86dcce1063","lists":[{"text":"What You Will Do","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed</li><li>Resolve account issues and complaints</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms</li>"},{"text":"What This Role Needs","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area</li><li>At least 6 years of experience in business management, sales, or project management is mandatory. Prior experience in e-commerce and managing key accounts will be a plus point</li><li>Fluency in both Bahasa and English is required</li><li>Able to multitask, prioritize, and manage time efficiently</li><li>Ability to negotiate, persuade and influence others</li><li>Excellent interpersonal, communication, presentation and analytical skills</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners</li>"}],"text":"Senior Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","descriptionBodyPlain":"About The Role\n\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063","applyUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063/apply"},{"additionalPlain":"About the Team\n\nThe Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721742951306,"descriptionPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","description":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","id":"099498bc-c171-4505-97d7-3a432d302e14","lists":[{"text":"What You Will Do","content":"<li>Work and collaborate in Financial systems technical projects, especially in SAP ABAP and SAP BTP technologies</li><li>Collaborate with cross-functional and cross-department teams to analyze complex business requirements and design scalable solutions</li><li>Develop and maintain technical specifications, design documents, and other project artifacts</li><li>Provide technical support and guidance to development teams, ensuring high-quality code delivery</li><li>Participate in code reviews, ensuring adherence to coding standards and best practices</li><li>Contribute to the development of technical architecture and design patterns, providing recommendations for improving performance, scalability, and maintainability</li><li>Stay up-to-date with the latest SAP technologies and trends, and evaluate new technologies for potential adoption</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of experience in SAP application development, with a focus on SAP ABAP and SAP BTP technologies</li><li>Proven track record of delivering successful scalable technical projects</li><li>Strong technical skills in ABAP OO, SAP Gateway, CDS, AMDP</li><li>Strong technical skills in SAP BTP or SAP Integration Suite</li><li>Knowledge on modern integration, Unix environment, cloud platform technologies, and other stacks is a plus</li><li>Excellent communication and interpersonal skills, with the ability to work effectively in a team environment</li><li>Strong analytical and problem-solving skills, with the ability to think creatively and strategically</li>"}],"text":"Senior SAP Technical","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","descriptionBodyPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14","applyUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1706837996316,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"93b5e2e0-272f-4091-b7aa-fafc06ca67c4","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>4-6+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"Senior SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4","applyUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4/apply"},{"additionalPlain":"About our Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About our Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1700733541559,"descriptionPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","description":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","id":"472ae629-87cb-4f8c-bb69-eae35cf3751e","lists":[{"text":"What you’ll do","content":"<li>Develop and implement test automation tools and frameworks to ensure continuous testing of product features</li><li>Collaborate with product managers and engineers to understand requirements, document test cases, and define rollout/release strategies</li><li>Perform performance, load, and scalability testing for new features and product releases.</li><li>Debug and diagnose defects uncovered during testing to determine root causes. Log bugs accurately and communicate issues clearly to engineering teams</li><li>Monitor systems in production to identify and troubleshoot defects or anomalous behavior.</li><li>Stay up-to-date with new testing methodologies and tools</li><div><br></div><div><br></div>"},{"text":"What you’ll need","content":"<li>5+ years experience in a QA, SDET or DevX role, with expertise in test automation</li><li>Proficiency with one or more programming languages like Java, Go, Kotlin, Python</li><li>Experience testing complex distributed systems and microservices architectures</li><li>Understanding of SQL and NoSQL databases</li><li>Familiarity with technologies like Kafka, Docker, Kubernetes</li><li>Knowledge of financial systems, mobile apps, or SaaS products is a plus</li><li>Excellent verbal and written communication skills</li>"}],"text":"Senior SDET - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e","applyUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721811900324,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","id":"153e42ca-cf5b-4f43-b09e-58eabda1e5fa","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 4 years of experience in professional testing in App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin, experience with Flutter is a plus)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa","applyUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1713506558950,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"076bd021-0157-42a4-89fd-51d9f236e490","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Payment Widget & Vendor Gateway","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490","applyUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490/apply"},{"additionalPlain":"About the Team\n\nThe Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.\n \nSome of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few. \n \nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.</div><div>&nbsp;</div><div>Some of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few.&nbsp;</div><div>&nbsp;</div><div>Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Marketplace","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1698659237440,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","id":"8d7ae844-168c-4e78-843a-94aceb7b1a66","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of relevant, hands-on experience with either  Golang, or Java</li><li>Ability to go in-depth across tech stacks used in the product</li><li>Experience working on large-scale, event-driven microservice architecture with active use of Kafka; ability to architect solutions based on this pattern</li><li>Familiarity with basic programming principles such as SOLID and TDD</li><li>Intermediate experience with Linux OS; ability to troubleshoot issues</li><li>A solid understanding of why we need to test code; experience implementing tests</li><li>Ability to understand/discuss design and performance trade-offs in complex systems</li>"}],"text":"Senior Software Engineer  - Marketplace","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66","applyUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711358848361,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"68f907a3-329f-411b-af2d-a66b38243919","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 5 years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>You have working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>You have Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, XGBoost, Keras</li>"}],"text":"Senior Software Engineer - Data Science Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919","applyUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919/apply"},{"additionalPlain":"About the Team\n\nWe are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.\n\nWe keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.\n\nThe Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.</span></div><div><br></div><div><span style=\"font-size: 16px\">We keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.</span></div><div><br></div><div><span style=\"font-size: 16px\">The Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721898140037,"descriptionPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","id":"57bb5e7f-9ea0-462f-ac36-5717b49d0380","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li><div><br></div>"},{"text":"What You Will Need","content":"<li>4-5 years of relevant experience. Hands-on in either Golang or Java</li><li>The ability to go into depth and breadth across tech stack used in the product vis-a-vis backend services, machine learning, data engineering, web development, data and analytics, infrastructure</li><li>Has worked on large scale event driven microservices architecture with an active use of Kafka and can architect solutions based on this pattern</li><li>Is familiar with basic programming principles such as SOLID and TDD</li><li>Has intermediate experience with Linux and is able to troubleshoot issues</li><li>Understands why we need to test code and has implemented tests</li><li>Able to understand/discuss design and performance trade offs in complex systems</li><div><br></div>"}],"text":"Senior Software Engineer - Go-food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px;\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380","applyUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718187134939,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"53c0b8a9-1a83-4c34-9a59-b5170ce54193","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Senior Software Engineer - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193","applyUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789054175,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","id":"fda395d6-457d-4a03-aaa1-33d513c3960b","lists":[{"text":"What You Will Do","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Software Engineer (Android) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b","applyUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b/apply"},{"additionalPlain":"About the Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713939159820,"descriptionPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","id":"d3b7122b-692b-4815-8aa9-f1d0259bccd5","lists":[{"text":"What Will You Do","content":"<li>Develop Java backend applications for the company, including web applications and server-side applications.</li><li>Be responsible for participating in the entire software development process, from requirement analysis to design, development, testing, and deployment, ensuring that our software products run efficiently and stably. The most significant thing is taking responsibility for results.</li><li>Architect and engineer robust, high-performance systems that can effortlessly handle scale, maintain reliability, ensure security, and gracefully handle faults.</li><li>Craft and refine our product vision into iterative Minimum Viable Products (MVPs), refining them as needed for scalability and adaptability.</li><li>Stay at the forefront of technology trends, continuously evaluating and incorporating new tools and methodologies to supercharge our development efforts.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","descriptionBodyPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5","applyUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789283382,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","id":"769b7391-e6fd-4923-9a92-e060f14e451d","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis, and MySQL.</li><li>Contributed to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization. Therefore, in addition to technical prowess, a keen understanding of financial business and self-motivation are emphasized.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>3+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Highly preferable experience in Golang</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d","applyUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d/apply"},{"additionalPlain":"About the team \n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the team </b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713777541586,"descriptionPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","description":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","id":"ad7a1160-4d07-4f4a-a2d3-c362afac18ac","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis and MySQL</li><li>Contribute to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred</li><li>Familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis</li><li>Familiar with Linux operating systems, understand database principles, and proficient in using databases like MySQL and Oracle</li><li>Good coding style and code specifications, and be able to independently complete project development</li><li>Good communication skills and teamwork spirit, and be able to collaborate effectively with other developers</li><li>knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Backend) - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","descriptionBodyPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac","applyUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710229562529,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"10dbc666-80f8-4250-85ee-59fa92d056aa","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Golang.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Good understanding of the full life cycle of the data warehouses.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Data Warehouse)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa","applyUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788927036,"descriptionPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","id":"bcd00ee0-2fb3-43c1-8401-ef184283ccc8","lists":[{"text":"What You Will Do","content":"<li>Design, build, deliver, and own development lifecycle from inception to production</li><li>Collaborate with the UI/UX team to write, design, and build high-quality front-end code and reusable components</li><li>Participate in and be responsible for front-end architecture design, and program decision-making, as well as creating technical standards and specifications;</li><li>Try improving engineering standards, tooling, and processes after understanding the business and team’s needs</li><li>Lead others through example, mentorship, teaching, code reviews, advocating, and maintaining suitable engineering standards for the team</li><li>Maintain close relations cross-department and gain from their expertise/share your learnings with them</li>"},{"text":"What You Will Need","content":"<li>3-4+ years of proven track record in JavaScript/ Typescript, CSS , HTML, DOM, network protocol, and other front-end related technologies, have in-depth experience in at least one of the mainstream front-end frameworks (React/ Vue /Angular, etc.) and understand the implementation principle</li><li>Good product awareness, service awareness, and sense of responsibility, can be independent and attention to user experience</li><li>Problem-Solving: Exceptional problem-solving skills with a track record of analyzing complex technical challenges and providing innovative solutions.</li><li>Communication: Excellent communication skills, with the ability to effectively convey technical concepts to both technical and non-technical stakeholders.</li><li>Leadership: Strong leadership experience, including mentorship, and technical guidance</li>"}],"text":"Senior Software Engineer (Front End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8","applyUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789167169,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","id":"e6c36118-5d4e-444b-922c-68e03c2ab82e","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Flutter and iOS.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3+ years of experience with iOS development and Flutter combined</li><li>Proficient in Swift programming, Cocoa, Xcode, the iOS SDK, Dart, and Flutter</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar).</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e","applyUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1708271973710,"descriptionPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","id":"389c0346-14e0-40e5-85c3-48d830db73b4","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Swift.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3 to 6+ years of experience with iOS development</li><li>Proficient in Swift programming, Cocoa, Xcode, and the iOS SDK</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar)</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Money Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","descriptionBodyPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4","applyUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899734506,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"449dd201-2d4d-47a0-9cd4-c7ddec91c88e","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data streaming products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Java.</li><li>Good understanding of real-time data streaming technologies like Flink, spark etc.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Real-Time Data Streaming)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e","applyUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1716821917651,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"8afd4278-a5a8-43f2-8718-2986433f2ddb","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.&nbsp;&nbsp;</li>"}],"text":"Senior Technical Program Manager - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb","applyUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717153383212,"descriptionPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","description":"<div><span style=\"font-size: 9pt\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","id":"3377f50a-d56f-42e0-acc5-b69d405a37a9","lists":[{"text":"What You Will Do","content":"<li>Identify and pursue strategic partnership opportunities that align with company goals - B2B in financial and non financial sectors</li><li>Negotiate terms and agreements with partners to drive mutual commercial successDevelop and maintain strong relationships with external partners to foster long-term collaboration</li><li>Collaborate with partners to create joint business plans aimed at achieving quarterly (QoQ) and yearly (YoY) growth targets</li><li>Monitor and analyze partnership performance, providing insights and recommendations for improvement</li><li>Work closely with internal teams, including sales, marketing, product, and finance, to ensure partnership initiatives are aligned with company objectives and obtain their successful buy in to projects and programs</li><li>Facilitate effective communication and collaboration across departments to gain buy-in for partnership strategies</li><li>Act as a liaison between partners and internal stakeholders to address any issues and optimize partnership outcomes</li><li>Be the first hand to handle issues related to the partnership and escalate the issue to the right parties (internal and external) to be solved</li><div><br></div>"},{"text":"What You Will Need ","content":"<li>Minimum Bachelor’s degree</li><li>Minimum 5 years of professional experience in partnership development or business development in companies such as start-ups, technology companies, management consulting, banking, or Fortune 500 companies</li><li>Data Analysis: Strong ability to crunch data and perform detailed data analysis. This includes interpreting complex datasets to derive actionable insights and support decision-making.</li><li>P&amp;L Understanding: Good understanding of Profit and Loss statements, with the ability to analyze financial performance and identify <a href=\"http://trends.Business\" class=\"postings-link\">trends.</a></li><li><a href=\"http://trends.Business\" class=\"postings-link\">Business</a> Acumen: Solid business acumen, enabling the development, management, and execution of business agreements and contracts. This involves a deep comprehension of business operations and strategic <a href=\"http://planning.Critical\" class=\"postings-link\">planning.</a></li><li><a href=\"http://planning.Critical\" class=\"postings-link\">Critical</a> Thinking and Problem Solving: Draws sound conclusions based upon a mixture of analysis and experience. Able to identify breakthrough solutions during tough negotiations or large-scale implementations with strategic <a href=\"http://partners.Communications\" class=\"postings-link\">partners.</a></li><li><a href=\"http://partners.Communications\" class=\"postings-link\">Communications</a> Skills: Promotes an environment of open communication. Convinces and engages others by using compelling arguments. Able to rigorously manage a portfolio of projects with strategic partners, unblock issues &amp; risks and manage expectations to ensure they are completed within target timelines and stakeholder <a href=\"http://expectations.Stakeholder\" class=\"postings-link\">expectations.</a></li><li><a href=\"http://expectations.Stakeholder\" class=\"postings-link\">Stakeholder</a> Management: Ability to develop strong, long lasting relationships with both internal and external stakeholders at all levels. Persuades and influences effectively by building support for ideas and initiatives through the effective presentation of facts and evidence. Identifies and anticipates that the partner and stakeholder needs to gain their commitment. Owns the end-to-end relationship with equivalent team and functional leads both internally and <a href=\"http://externally.B2B\" class=\"postings-link\">externally.</a></li><li><a href=\"http://externally.B2B\" class=\"postings-link\">B2B</a> Negotiation Skills: A fair, unbiased mediator and uses diplomacy and tact to diffuse tense situations comfortably</li><li>Resiliency : Demonstrates resilience &amp; composure, even in difficult or adverse circumstances. Makes and carries through unpopular or difficult decisions that are in the best interest of the team. Is able to resist the pressure to make quick decisions where due consideration is <a href=\"http://required.Abilities\" class=\"postings-link\">required.</a></li><li><a href=\"http://required.Abilities\" class=\"postings-link\">Abilities</a> to navigate and execute in a highly ambiguous environmentLocal candidates is a must</li><div><br></div>"}],"text":"Senior/Partnership Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt;\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","descriptionBodyPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","hostedUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9","applyUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9/apply"},{"additionalPlain":"About the Team\n\nAs a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.\n\nOur team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>As a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.</div><div><br></div><div>Our team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705293453270,"descriptionPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","id":"9b2d9240-3315-4b28-a7d6-73e2a097c8d7","lists":[{"text":"What You Will Do","content":"<li>Proactively monitor and troubleshoot system performance, identifying and addressing potential issues.</li><li>Collaborate with development teams to design and implement scalable and resilient system architectures.</li><li>Develop and maintain automation tools to streamline processes and enhance overall system efficiency.</li><li>Participate in incident response activities, conducting root cause analysis</li><li>Contribute to the ongoing improvement of reliability, scalability, and performance of critical infrastructure.</li><li>Work closely with cross-functional teams to align SRE efforts with broader organizational goals.</li>"},{"text":"What You Will Need","content":"<li>Solid understanding of cloud platforms such as GCP, and expertise in deploying and managing services within these environments.</li><li>In-depth knowledge of containerization technologies like Docker and orchestration tools such as Kubernetes</li><li>Proficiency in programming languages like Python, Go, or Java, with a strong software engineering foundation</li><li>Able to manage small teams and also can work as an individual contributor</li><li>Familiarity with Linux System, monitoring and logging tools to ensure comprehensive system visibility such as Prometheus, Grafana, and ELK stack</li><li>Proven track record of implementing and maintaining automation for deployment, scaling, and system orchestration.</li>"}],"text":"Site Reliability Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","descriptionBodyPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7","applyUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7/apply"},{"additionalPlain":"About the Team \n\nOur Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.\n\nHaving a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.  \n\nWe are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Our Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.</div><div><br></div><div>Having a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.&nbsp;&nbsp;</div><div><br></div><div>We are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717664713208,"descriptionPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","id":"f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","lists":[{"text":"What Will You Do ","content":"<li>Be the person in charge to create social media campaign and content; from observing trends and references, brainstorming, planning to execution (including schedule and post)</li><li>Develop social media campaigns strategies collaborate with other stakeholders&nbsp;&nbsp;</li><li>Create KOL strategy collaborate with stakeholders and third parties</li><li>Utilizing social media tools to analyze social media campaign, content, and KOL to gather insight and action plan</li><li>Collaborate with brand marketing to deliver/support marketing needs</li>"},{"text":"What Will You Need","content":"<li>At least 3-5 years related work experience from an advertising agency or start-up</li><li>Strong writing, editing, and proof-reading skills</li><li>Ability to communicate ideas clearly; a strong analytical, data-driven mindset</li><li>Broad knowledge of social media landscape, platforms, and technologies</li><li>Have interest in digital platforms, particularly in social media, and a willingness to learn more about this digital space</li><li>Strong team player with a proactive attitude and a creative/innovative mind to collaborate with multiple stakeholders</li><li>Strong analytical abilities to read, interpret, and utilize data, and to come up with actionable points for optimization and/or experimentation</li><li>Robust and detail-oriented to handle multiple works</li>"}],"text":"Social Media Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","descriptionBodyPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","applyUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898426994,"descriptionPlain":"\n","description":"<div><br></div>","id":"180b3e9e-cfb9-471d-8c30-410aef031535","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features &amp; participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team &amp; be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment &amp; work closely on the production environment, maintaining product’s&nbsp; uptime, reliability and SLOs</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby Proficient in OOP, SQL, Design Patterns</li><li>Experience with data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer  - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535","applyUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897603986,"descriptionPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"96562e50-0bf7-4a14-a910-4ef63f16d451","lists":[{"text":"What You Will Do","content":"<li>Build large-scale and high-performance services to develop simple, easy-to-use products for our unique end customers</li><li>Design and develop a highly maintainable and reliable Android app</li><li>Write clean and tested code, mostly in Kotlin for Android native environment</li><li>Coordinate with other teams (Product Management, UX/Design, Backend Engineering, and Quality Engineering teams) on building and managing the Android app</li><li>Implement tech excellence in the Android development environment</li><li>Help in a constant exploration of new technology and tools</li><li>Deliver solutions that bring a positive impact to low-income communities through up-to-date software technologies</li><li>Going forward, you will have to work on flutter application as well</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience in software engineering</li><li>Strong knowledge of Kotlin, Android tools and framework, and Android Studio</li><li>Good skill in unit tests. Plus points for UI tests</li><li>Experience in using app vitals and performance monitoring systems</li><li>Experience building an end-to-end system, preferably for a large user base</li><li>Strong attention to detail, particularly on software engineering fundamentals, testing methodologies, and quality</li><li>Familiarity with Android design patterns</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - Android (Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451","applyUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451/apply"},{"additionalPlain":"About the Team\n\nThe Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).\n\nOne of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.\n\nOff hours, you’d probably find us hang out, dinner together or playing games\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).</div><div><br></div><div>One of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.</div><div><br></div><div>Off hours, you’d probably find us hang out, dinner together or playing games</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697610584742,"descriptionPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","id":"cd554abc-dc06-4177-be50-ccbc638fd6d9","lists":[{"text":"What You Will Do","content":"<li>Work closely with team lead to deliver product features that enable efficient handling of queries for our internal users (customer service agents) and complaints raised by external users (customer, driver, and merchant)</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems</li><li>Write code that’s clear, concise, performant, tested and easily understood by others</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Writing technical documents and providing technical training for end users if necessary</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2-3+ years of hands-on experience in designing, developing, testing, and deploying applications on Go-Lang, Clojure, Java, Ruby, or OOPL large-scale applications</li><li>In-depth experience&nbsp;of at least one programming language and framework, deep understanding of SQL databases, Linux, Kafka, Redis, and RabbitMQ</li><li>Proficient in OOP, SQL, Design Patterns Data modeling experience in Relational databases</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate risks</li>"}],"text":"Software Engineer - Customer Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9","applyUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><span style=\"font-size: 16px\"><b>About the Team</b></span></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897318094,"descriptionPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><span style=\"font-size: 16px\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"4439eb62-6f08-444b-946d-1dff07d7d0d3","lists":[{"text":"What You Will Do","content":"<li>Working on mobile applications iOS and going forward you will work on flutter application</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, communicate project/development status to internal and external teams in a timely fashion</li><li>Participating in the design review process, seeking and providing constructive criticism</li><li>Improving code structure and architecture in service of testability and maintainability</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentations of how their design and architecture evolves over time</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>2-4 years of experience with iOS development</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in Swift programming, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Understanding of iOS Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third party libraries for networking, async, image loading etc</li><li>Good analytical and problem solving skills</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - iOS ( Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3","applyUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3/apply"},{"additionalPlain":"About the Team\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716980506841,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","id":"930cfb6b-99e3-4334-bc10-3fac18f8eff0","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Helping out in onboarding process by sharing contexts and pairing with new member of the team</li><li>Start mentoring or guiding SE1</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years relevant software development experience through internship stint and/or college projects</li><li>Proficient in Kotlin programming, Java and the Android APIs. </li><li>Strong knowledge in Android Apps architecture and implementationAbility to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular libraries for networking, async, image loading etc.</li><li>Well-versed with Agile methodologies, TDD and Test Engineering and Automation.</li>"}],"text":"Software Engineer (Android) - Gofood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0","applyUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0/apply"},{"additionalPlain":"About the Team\n\nMerchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nOur team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Merchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>Our team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Merchant Lending","allLocations":["Jakarta"]},"createdAt":1721735169268,"descriptionPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","id":"dab778da-b4eb-4e7e-bc8e-997af7210d52","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain user-facing features, translating designs and requirements into well-designed, testable and efficient code</li><li>Collaborate with other team members and stakeholders to deliver high-quality software solutions</li><li>Troubleshooting and debugging to optimize performance.</li><li>Be proactive, ask questions, and be an active member of the team striving towards improving the merchant experience&nbsp;</li><li>Learn new technologies to keep yourself updated and brainstorm with the managers about using the new technologies in day-to-day problem-solving</li>"},{"text":"What You Will Need","content":"<li>Degree/Diploma in Computer Science, Engineering, or related field.</li><li>2+ years of experience in developing using Java</li><li>Understand programming practices such as separation of concerns, unit testing, and writing self-documenting code</li><li>Familiarity with mainstream frameworks like Spring, Spring Boot, and Linux operating systems, understanding of database principles, and proficiency in using databases like MySQL or PostgreSQL.</li><li>Familiarity with front-end related technologies and concepts such as Javascript/Typescript, CSS, HTML, DOM, network protocol, and mainstream front-end frameworks</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (Back End) - Merchant Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52","applyUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713521223842,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"331177df-4294-4bc1-93a4-6459ff18ef97","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97","applyUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899384459,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"c0e92e19-ce60-4cfc-a58b-553f17452483","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483","applyUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483/apply"},{"additionalPlain":"About the Team\n\nConsumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1714016329286,"descriptionPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","id":"88358de8-e37b-4bd6-9afe-359eea3128b9","lists":[{"text":"What You Will Do","content":"<li>Own feature development from end-to-end, constantly pair with junior engineers, and improve them.</li><li>Write code that's clear, concise, performant, tested, and easy to understand by other teams and engineers.</li><li>Contribute to the design and development of highly scalable, available, reliable, secure, and fault-tolerant services.</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices.</li><li>Deep dive and debug production issues across services and levels of the stack when needed.</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently.</li>"},{"text":"What You Will Need","content":"<li>Passion for software development</li><li>At least 3 years of relevant software development experience with consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Ability to learn or use Java, Kotlin, and JS, proficiency in at least one of them</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, database consistency and transactionality, asynchronous programming, fault tolerance and monitoring, performance, feature flags, and backward compatibility&nbsp;</li><li>Understanding of a mobile application’s interaction with the back-end and other systems</li><li>Deep understanding of relational databases; ability to design performant, easy-to-understand architectures, and know-how for applying changes with no downtime to production systems</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, AWS, GCP</li>"}],"text":"Software Engineer (Full Stack) - BNPL","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","descriptionBodyPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9","applyUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9/apply"},{"additionalPlain":" About the team\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div>&nbsp;<span style=\"font-size: 16px\">About the team</span></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899689491,"descriptionPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","id":"89a62415-b145-4593-ac20-b82ec0ccfacb","lists":[{"text":"What You Will Do","content":"<li>Solve technical problems and build the next generation of products for our consumers</li><li>Spike new technologies and find a viable way to improve customers experience</li><li>Improve the testability and maintainability of the code</li><li>Build reusable iOS software components for interfacing with multiple applications</li><li>Improve and stabilize IOS sdks used by number of internal and external clients</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>At Least 2 years of full-time iOS engineering experience</li><li>Experience developing, maintaining, and innovating large scale, consumer mobile application</li><li>Predictability and balance of product delivery speed and quality</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in <b>Swift programming</b>, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Working experience with popular libraries for networking, async, image loading, etc</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><li>Experience and knowledge of writing testable and high-quality code</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (iOS) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","descriptionBodyPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb","applyUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb/apply"},{"additionalPlain":"About the Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</div><div><br></div><div>Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</div><div><br></div><div>As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).</div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1719909295384,"descriptionPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","description":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","id":"1a190954-9482-4953-a750-f2ae33a50003","lists":[{"text":"What You Will Do","content":"<li>Develop and Test: Write, test, and maintain software across our platforms, ensuring robustness and scalability.</li><li>Collaborate: Work closely with senior engineers and cross-functional teams including Backend, Frontend, Mobile, and QA to design and execute solutions.</li><li>Learn and Grow: Receive mentorship from senior engineers, enhancing your understanding of software development processes and best practices.</li><li>Contribute: Play a key role in the development and optimization of new features and systems within Midtrans.</li>"},{"text":"What You Will Need","content":"<li>Currently enrolled in or recently graduated with a degree in Computer Science, Software Engineering, or a related field.</li><li>Strong foundational knowledge in at least one programming language (Java, Python, JavaScript, etc.).</li><li>Understanding of basic software development concepts and methodologies.</li><li>Familiarity with version control systems, preferably Git.</li><li>Problem-Solving: Ability to think critically and solve complex problems.</li><li>Communication: Excellent verbal and written communication skills.</li><li>Teamwork: Eagerness to work within a team-oriented environment.</li><li>Adaptability: Openness to learning new technologies and methodologies.</li>"}],"text":"Software Engineer Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","descriptionBodyPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003","applyUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003/apply"},{"additionalPlain":"About the Team\n\nThe Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">The Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721305380078,"descriptionPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","id":"75c0d634-b28a-4f10-8f5a-efacb32b6444","lists":[{"text":"What You Will Do","content":"<li>Collaborate with product engineers to unify and optimize build standards across Android apps</li><li>Enhance build performance and streamline development processes</li><li>Identify and resolve bottlenecks in the current build system.Forecast and future-proof Android platform engineering services</li><li>Implement best engineering practices and ensure adherence across product groups</li><li>Conduct thorough code reviews and provide constructive feedback</li><li>Mentor junior engineers and support their professional growth</li><li>Participate in architectural design reviews and contribute to technical decision-making</li>"},{"text":"What You Will Need","content":"<li>5+ years of mobile engineering experience with Android as primary expertise</li><li>Proficiency in writing clear, concise, and maintainable code</li><li>Experience with collaborating on projects involving multiple teams</li><li>Strong understanding of mobile app architecture, testing, and performance optimization</li><li>Passion for building scalable and reusable systems</li><li>Ability to make informed decisions in architectural design reviews</li><li>Experience with build systems and CI/CD pipelines</li><li>Familiarity with Flutter or a willingness to learn it</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Sr. Software Engineer (Android) - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444","applyUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444/apply"},{"additionalPlain":"About the Team\n\nOur Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nTransport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)  using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Transport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)&nbsp; using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717676182978,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","id":"22ac4805-bcbe-4698-9e51-cb25754ac244","lists":[{"text":"What You Will Do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Actively mentor SE/ASEs&nbsp; in the team</li><li>Translate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environments</li><li>Improve engineering standards, tooling and processes</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applications</li><li>Have expertise in at least one of Go or Java</li><li>In-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etc</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"Sr. Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244","applyUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks\n\nYou get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks</span></div><div><br></div><div><span style=\"font-size: 16px\">You get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Jakarta"]},"createdAt":1713436041495,"descriptionPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","id":"e2bbb29c-85ef-4db2-9ea7-93af9101b634","lists":[{"text":"What You Will Do","content":"<li>Automate mechanism to make sure app performance adheres to the standards set internally</li><li>Building tools that would alleviate mobile engineer's development experience and productivity&nbsp;</li><li>Build dashboard and alerting system around mobile app performance (using tools like Firebase, Instabug, etc)</li><li>Foster a development culture that focuses on the quality of delivery</li><li>Creating and maintaining SDKs like networking, logging, etc. These sdk’s are responsible for providing common solutions to products across all iOS mobile teams</li><li>Continuously discover, evaluate, and implement new technologies to maximize development efficiency</li><li>Create excellent, clear, and insightful documentation ex: guidelines, best practices, how-to, FAQs etc</li>"},{"text":"What You Will Need","content":"<li>Atleast 3+ years of mobile engineering experience with iOS as primary expertise</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Ability to can take (or pitch) technical decisions, own it and raise impediments early if needed</li><li>You are very well versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>You have a passion for building scalable and composable systems that would last long</li><li>You are a hands-on engineer with a focus on writing easy to read code than over-engineering</li><li>You are a great communicator who can express your ideas clearly and build consensus to push technical agendas</li>"}],"text":"Sr. Software Engineer (iOS) - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634","applyUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634/apply"},{"additionalPlain":"About the Team\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\n\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</span></div><div><br></div><div><span style=\"font-size: 16px\">We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717559195275,"descriptionPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","id":"8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","lists":[{"text":"What You Will Do","content":"<li>Help provide clarity and direction for marketing campaigns or initiatives</li><li>To become the bridge between the Creatives and the marketing, media, social, design, product and research team</li><li>Always bringing the consumer perspective into the creative process in Gojek by simply staying in touch with society and the trends that are changing it</li>"},{"text":"What You Will Need","content":"<li>You have at least 5 years of strategy experience in an agency or related environment</li><li>Ability to deliver a clear, insight-based strategic recommendation in the form of a written brief</li><li>Ability to support Creatives and Designers&nbsp; with relevant stimulus, routes, or advice</li><li>Ability to visualize simple customer journeys in clear &amp; compelling ways</li>"}],"text":"Strategic Planner - Creative Labs - #10088","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px;\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","descriptionBodyPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","applyUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713867338946,"description":"","descriptionPlain":"","id":"afb5bc40-aa4f-4837-a2d9-7d38eade2599","lists":[{"text":"What will you do","content":"<li>Assume ownership of key performance indicators (KPIs) driving revenue and profitability for Consumer Lending <a href=\"http://business.Develop\" class=\"postings-link\">business.</a></li><li><a href=\"http://business.Develop\" class=\"postings-link\">Develop</a> comprehensive strategies and roadmaps to achieve growth objectives through a combination of <a href=\"http://initiatives.Identify\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Identify\" class=\"postings-link\">Identify</a> growth opportunities within the consumer lending business by analyzing business data, transactional data, customer activity within platforms, and leveraging customer <a href=\"http://insights.Lead\" class=\"postings-link\">insights.</a></li><li><a href=\"http://insights.Lead\" class=\"postings-link\">Lead</a> the prioritization process, strategizing, and focusing on solutions aimed at addressing user needs and enhancing user <a href=\"http://experience.Validate\" class=\"postings-link\">experience.</a></li><li><a href=\"http://experience.Validate\" class=\"postings-link\">Validate</a> business strategies and hypotheses through rigorous experimentation and statistical <a href=\"http://methodologies.Present\" class=\"postings-link\">methodologies.</a></li><li><a href=\"http://methodologies.Present\" class=\"postings-link\">Present</a> findings and insights to senior management to inform strategic decision-making regarding feature prioritization and impact <a href=\"http://analysis.Cultivate\" class=\"postings-link\">analysis. </a></li><li><a href=\"http://analysis.Cultivate\" class=\"postings-link\">Cultivate</a> and manage partnerships with external stakeholders.</li>"},{"text":"What will you need","content":"<li>BS/MS in Business, Engineering, Computer Science, Math, Economics, Statistics, or <a href=\"http://equivalent.8-10\" class=\"postings-link\">equivalent.</a></li><li><a href=\"http://equivalent.8-10\" class=\"postings-link\">8-10</a> years of working experience with strong business <a href=\"http://acumen.End\" class=\"postings-link\">acumen.</a></li><li><a href=\"http://acumen.End\" class=\"postings-link\">End</a> to end problem-solving mindset that can work in increments and <a href=\"http://exponents.Strong\" class=\"postings-link\">exponents.</a></li><li><a href=\"http://exponents.Strong\" class=\"postings-link\">Strong</a> project management skills to manage complex projects, also can manage and prioritize multiple internal and external <a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">Proficiency</a> in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with good knowledge of SQL and experimentation processHustle is essential, moving quickly and executing to allow for continual iteration is a core competency of the teamExperience in a financial services and technology companies is preferred.</li>"}],"text":"Strategy Senior Manager, Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599","applyUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599/apply"},{"additionalPlain":"Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1709264557847,"descriptionPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","description":"<div><span style=\"font-size: 10pt\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","id":"eaab5bee-084d-4cdc-bd08-63230251009c","lists":[{"text":"What you will do","content":"<li>Develop and maintain supply related dashboards to monitor key metrics and compare achievements against targeted <a href=\"http://goals.Analyze\" class=\"postings-link\">goals.</a></li><li><a href=\"http://goals.Analyze\" class=\"postings-link\">Analyze</a> various data points, detect anomalies and spot trends to drive business and strategic decision-making on supply <a href=\"http://initiatives.Collaborate\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Collaborate\" class=\"postings-link\">Collaborate</a> with the BI, Data Science, Marketing, and Product Management teams to ensure alignment on data analysis, methodologies, insights, and recommendations and proactively escalate issues to relevant <a href=\"http://stakeholders.Analysis\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Analysis\" class=\"postings-link\">Analysis</a> on the competitive intelligence insights and <a href=\"http://findings.Be\" class=\"postings-link\">findings.</a></li><li><a href=\"http://findings.Be\" class=\"postings-link\">Be</a> the go-to person on anything related to the supply health metrics and analysis.</li><div><br></div>"},{"text":"What you will need","content":"<li>A BS/MS in Business, Engineering, Computer Science, Mathematics, Economics or equivalent experience</li><li>3+ years of experience within one or more of the following fields: Business Analytics, Strategy and Planning, Growth or relevant functions</li><li>Comfortable analyzing large amounts of raw data with an obsession to detail and accuracy of data</li><li>Able to uncover the story and relationship behind the numbers and communicate the insights to a wider audience</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Proficiency in multiple analytic, database, and visualization tools (e.g., Tableau, Looker Studio, etc.) along with strong knowledge of SQL</li><li>A scientific and hypothesis-driven thinking process with the ability to work in increments and exponents</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders </li><div><br></div>"}],"text":"Supply Strategy Data Analyst [Ads]","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","descriptionBodyPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c","applyUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c/apply"},{"additionalPlain":"About the team \n\nWe are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.\n\n","additional":"<div><b>About the team</b>&nbsp;</div><div><br></div><div>We are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - ESG","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721114762245,"descriptionPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","id":"1a303596-73f9-4d05-85f9-73cd361f03ef","lists":[{"text":"What you will do","content":"<li>Leading GoTo Group’s sustainability commitments and related workstreams, focusing on the company's environmental and socio-economic impact and financial inclusion of the ecosystem.</li><li>Overseeing Zero Barriers as a socio-economic pillar, focusing on the development of in-house financial products and services aimed at improving the economic well-being and sustainable livelihoods of GoTo’s drivers and merchant partners.</li><li>Implementing impact measurement frameworks to transparently communicate social and economic benefits resulting from company initiatives, reinforcing accountability.&nbsp;</li><li>Driving the implementation of comprehensive Diversity, Equity, and Inclusion (DEI) policies within GoTo, to foster a culture of equality and respect organization-wide.&nbsp;</li><li>Ensuring proactive compliance with relevant environmental, social, and governance (ESG) regulations, surpassing standards to uphold ethical business practices.</li>"},{"text":"What you will need","content":"<li>Extensive experience in ESG strategy, preferably within the tech industry.&nbsp;Strong understanding of global and local sustainability regulations and standards. (GRI, POJK, MSCI, S&amp;P, etc.)</li><li>Proven track record in leading sustainability initiatives and integrating them into business operations.</li><li>Excellent stakeholder management and communication skills.&nbsp;</li><li>Ability to analyze complex data and translate it into actionable strategies.&nbsp;Innovative thinking and problem-solving abilities.&nbsp;</li><li>Leadership skills with the ability to drive cultural change and motivate teams.&nbsp;</li><li>Proficiency in project management and sustainability reporting tools.</li>"}],"text":"Sustainability Senior Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef","applyUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720377852482,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically-oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.</li>"}],"text":"Technical Program Manager - Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","applyUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720689871979,"descriptionPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","id":"bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Support Head in establishing and strengthening relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors</li><li>Project Leadership: Support multiple projects in partnership with government institutions, focusing on Transport and Mobility technology.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances</li><li>Project Management: Support public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government</li><li>Established network among government stakeholder with a proven impact on policy decisions</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Transport and Mobility PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","descriptionBodyPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","applyUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705901801143,"descriptionPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","description":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","id":"17408b81-f5a0-4f15-afae-cc04ed7e43b6","lists":[{"text":"What You Will Do","content":"<li>Prepare Risk reporting and position reporting</li><li>Conduct assessments to define and analyze possible risks</li><li>Evaluate the gravity of each risk by considering its consequences</li><li>Design processes to eliminate or mitigate potential risks</li><li>Evaluate existing policies and procedures to find weaknesses</li><li>Prepare reports and present recommendations</li><li>Ensure risk exposures of the company is within stipulated limits</li><li>Work closely with other business stakeholders</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years&nbsp;</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal and external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL will be an advantage</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Underwriting and Credit Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","descriptionBodyPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6","applyUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6/apply"},{"additionalPlain":"About The Team\nMerchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Merchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721636128423,"descriptionPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","id":"a007af4b-690d-4487-874d-f04ce3f62ce0","lists":[{"text":"What You Will Do","content":"<li>Maintain relationship with BPO vendor and regularly evaluate their productivity&nbsp;</li><li>Become a COE of merchant engagement framework for region team</li><li>Assisting SM Merchant Engagement in managing milestones, timeline, as well the stakeholders engagement related to the managed projects.</li><li>Develop and updating Key Insights and Analysis related to Unmanaged merchants performances</li>"},{"text":"What This Role Needs","content":"<li>At least 2 years experience in field sales or telemarketing, especially with a proven track record of managing local / regional business in reputable companies</li><li>Experienced in managing large business partner such as distributor or outsourcing vendor</li><li>Have experience in basic to intermediate data analytics skills</li><li>Having ability to turn insight into actionable plan</li><li>Strong business acumen with proven track record in stakeholder management</li>"}],"text":"Unmanaged Merchant Engagement Senior Associate - #10326","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","descriptionBodyPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0","applyUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119556899,"descriptionPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","id":"147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","lists":[{"text":"What you will do","content":"<li>Own the GoMart Growth Strategy and Promotion budgetTake charge of monthly budgeting and weekly execution with an emphasis on growth while maintaining profitability</li><li>Lead initiatives, strategies, and implementation, with a primary focus on the customer lifecycle funnel targeting the acquisition of new and churned users while growing retention of existing customers through a compelling offer.</li><li>Experiment with a combination of multiple initiatives (e.g. vouchers/promotion, product or pricing changes) to validate initiatives through statistical analysis</li><li>Use data across customer, driver, and merchant activity from multiple products to hypothesize potential solutions and test them in practice&nbsp;</li><li>Collaborate with Merchandising, Marketing, Product, and Operations teams in the development and implementation of initiatives and strategies</li><li>Prepare routine reports and present findings to leadership as the basis of rationale and recommendations for strategic decision-making</li>"},{"text":"What you will need","content":"<li>At least 5 years of experience in strategy or growth role at a tech company, e-commerce, or management consulting background</li><li>Strong proficiency in Microsoft Excel; Understanding of SQL and other statistical tools is a must.</li><li>Strong business acumen, an end-to-end problem-solving mindset with the ability to work in increments and exponents and balance attention to detail with swift execution</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"User Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","applyUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663/apply"}]
-  recorded_at: Mon, 29 Jul 2024 09:06:46 GMT
+        [{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721638994130,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","id":"f53cae40-f605-4215-9a82-b48c5db508b5","lists":[{"text":"What you will do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance.</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Actively mentor SE/ASEs&nbsp; in the teamTranslate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environmentsImprove engineering standards, tooling and processes</li>"},{"text":"What you will need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applicationsHave expertise in at least one of Go or JavaIn-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etcExcellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"#10010 Senior Backend Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek.&nbsp;</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Backend Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the Logistic experience team you will be working with other peers to power the core booking experience of logistic orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5","applyUrl":"https://jobs.lever.co/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5/apply"},{"additionalPlain":"The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.\nThe Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.\nWe, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.\n","additional":"<div><span style=\"font-size: 10pt\">The Logistics team at Gojek oversees all aspects of package delivery, from solving intracity peer-to-peer delivery for Gojek users to developing APIs for our B2B product line. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities. It’s our job to ensure that our Logistics services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 10pt\">The Consumer Logistics vertical helps customers book logistics orders from their choice of available products like (GoSend Instant, GoSend Same day, GoBox, GoShop car, etc) using the Gojek customer app. On a day-to-day basis teams are involved in brainstorming and developing solutions for different optimizations that bring efficiency in the ecosystem making the Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers.</span></div><div><span style=\"font-size: 10pt\">We, the GoTroops, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other. We work as a team to get our job done well and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721640901865,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","description":"<div><span style=\"font-size: 10pt\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","id":"ce351965-e2f9-4f8f-8cad-38fb4cd045e9","lists":[{"text":"What you will do","content":"<li>Independently responsible for the entire lifecycle of high-complexity Android projects or features including software design, development, and deployment within their team</li><li>Planning &amp; timely delivery of work within their teamImproving code structure and architecture in service of testability and maintainability</li><li>Writing, co-writing, and reviewing design documentation</li><li>Leading new language/framework POCsParticipating in the design review process, seeking and providing constructive criticism</li><li>Tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Ensuring that their team has strong sets of documentation and journals of how their design and architecture evolve over time</li><li>Ensuring predictability, quality &amp; throughput of their team's delivery</li><li>Prioritizing and valuing work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalating challenges that are outside their control but affect the team's delivery</li><li>Prioritizing work based on understanding the trade-off between quality, tech-debt, and delivery</li><li>Leading effort to work with other teams to solve problems affecting the delivery of their team</li><li>Participating in prioritization of cross teams initiatives &amp; leading those within their own team</li><li>Splitting complex engineering task into smaller components which can be developed by junior engineers in the team</li><li>Mentoring other engineers on an individual basis</li><li>Participating in the hiring process (by meeting candidates, and attending recruiting events)</li><li>Conducting engineering interviews</li>"},{"text":"What you will need","content":"<li>Should have at least 4 years of experience with Android developmentProficient in Kotlin programming, Java, and Android APIs.</li><li>Strong knowledge of Android Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standards across the teamWorking experience with popular libraries for networking, async, image loading, etc.</li><li>Well-versed with Agile methodologies, TDD, and Test Engineering &amp; Automation.</li><li><b>Bonus points if:&nbsp;</b>Have experience in Running A/B or multi-variant experiments for features that you built.</li>"}],"text":"#10279 Senior Android Developer (Logistic)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop &amp; GoBox orders on Gojek. </span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Senior Software Engineer. In this role, you will be an integral player in Android engineering at Gojek - designing and developing GoJek app which powers one of South-East Asia’s biggest ride-hailing, food, and logistics experiences. As a member of the Consumer Logistics team, you will be working with other peers to power the Gosend, GoShop & GoBox orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9","applyUrl":"https://jobs.lever.co/GoToGroup/ce351965-e2f9-4f8f-8cad-38fb4cd045e9/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898011592,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"657d7112-420a-4e42-8bfd-1b790fc05155","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"#10357 Senior Software Engineer - Go-food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155","applyUrl":"https://jobs.lever.co/GoToGroup/657d7112-420a-4e42-8bfd-1b790fc05155/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721901545426,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"87b4d0e4-219e-4ba7-9433-27220623ab69","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10358 Software Engineer - Backend (Groceries)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69","applyUrl":"https://jobs.lever.co/GoToGroup/87b4d0e4-219e-4ba7-9433-27220623ab69/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898703682,"descriptionPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","description":"<div><span style=\"font-size: 10pt\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","id":"2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","lists":[{"text":"What you will do","content":"<li>Own product development on functional and nonfunctional requirements, OKRs and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle.</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvementsWork with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals.&nbsp;&nbsp;</li><li>Write code that is clear, concise, performant, tested and easily understood by others.</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What you will need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design <a href=\"http://Patterns.Experience\" class=\"postings-link\">Patterns.Experience</a> with functional programming, data modelling experience in Relational and/or NoSQL databases is a plus.&nbsp;Well-versed with agile methodologies and clean coding <a href=\"http://practices.Curiosity\" class=\"postings-link\">practices.Curiosity</a> to understand how systems internally work, and hunger to continuously challenge the status quo of our tech stackHands on knowledge of unit testing methodologies and frameworksExperience troubleshooting server performance - memory issues, GC tuning, resource <a href=\"http://leaks.Experience\" class=\"postings-link\">leaks.Experience</a> working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis or similarExperience navigating large code bases with the expertise to propose and implement refactorings as needed, coupled with a keen eye for code review</li>"}],"text":"#10359 Software Engineer - Backend","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.&nbsp; </span></div>","descriptionBodyPlain":"In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958","applyUrl":"https://jobs.lever.co/GoToGroup/2b1df9c9-7ff9-41b4-8ba9-fc92b7a89958/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain area. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as providing necessary advice to them in increasing transaction overtime.</div>","categories":{"department":"ODS - Regions","location":"Bali","team":"East Java, Bali, Nusra Regions","allLocations":["Bali"]},"createdAt":1720778770433,"descriptionPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"73172a46-5486-4860-a256-8e17225c4a47","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transaction</li><li>Create regular report to what's happen in their respective areas toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Fresh Graduate are welcome to Apply&nbsp;</li><li>2 years relevant experience with preferable industries: top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region will be a plus</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Bali)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build &amp; maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role\n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their areas and also build & maintain relationships with the network of all merchants in their territory including regular visits upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47","applyUrl":"https://jobs.lever.co/GoToGroup/73172a46-5486-4860-a256-8e17225c4a47/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721704703939,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"885b2af9-c94a-4010-b0c4-c6ea7812039b","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b","applyUrl":"https://jobs.lever.co/GoToGroup/885b2af9-c94a-4010-b0c4-c6ea7812039b/apply"},{"additionalPlain":"About The Team\n\nAccount Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.\n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Account Executive (AE) will work as a team within a certain district and closely collaborate with the Merchant Engagement and Sales Support teams. Ideally, an AE regularly visits assigned merchants to see what really happened on the ground as well as provide necessary advice to them in increasing transactions over time.</div><div><br></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"Jabodetabek Regions","allLocations":["Tangerang"]},"createdAt":1721037961422,"descriptionPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","description":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","id":"94efd0c8-e79b-41e1-aa37-a7a4c08c108f","lists":[{"text":"What Will You Do","content":"<li>Prepare sales forecasts and budgets; set transaction targets in areas like product mix,sales volume, market shares in their territory</li><li>Analyze consumer behavior, market insight, field situation, and market trend in their territory</li><li>Regular review leads merchants (i.e. monitor merchant growth, transfer merchants to new categories, competitor activity, etc.)</li><li>Provide advices to the merchant based on valid data analytics result in order to increase number of transactions</li><li>Create regular report to what's happen in their respective territory toward Regional/Nation-Wide company strategy</li>"},{"text":"What Will You Need","content":"<li>Having at least 3 years relevant experience with preferable industries : top 5 FMCG / Telecommunication company</li><li>Preferably has spent significant time (&gt;1 year) in representative area and has strong network and knowledge about the region</li><li>Has existing relationship or able to bridge, develop and maintain good relationship with key partner</li><li>Strong business sense and have good understanding of the markets, customers, and competitors</li><li>Fact-based / number-oriented individual, who is comfortable working under pressure in a fast-paced and ambiguous environment</li>"}],"text":"Account Executive (Tangerang)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Account Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build &amp; maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.</div>","descriptionBodyPlain":"About the Role \n\nAccount Executive (AE) is mainly responsible to execute Regional/Nation-Wide Sales strategy within their territory and also build & maintain relationships with the network of all merchants in their territory including regular visit upon assigned leads. They should understand what the merchant needs and provide advice upon it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f","applyUrl":"https://jobs.lever.co/GoToGroup/94efd0c8-e79b-41e1-aa37-a7a4c08c108f/apply"},{"additionalPlain":"About the team\n\nOur GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n","additional":"<div><b>About the team</b></div><div><br></div><div>Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</div><div><br></div><div>Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</div>","categories":{"department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721623842937,"descriptionPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","id":"94f85d13-6fe6-43a8-96c8-4898ab75d908","lists":[{"text":"What Will You Do","content":"<li>Executing campaign creation of our merchants through our inhouse portal and assist in troubleshooting to our product managers and engineers&nbsp;</li><li>Proactively improve the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Learn to introduce beneficial business changes through well-written document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Support and coordinate with multiple stakeholders to ensure seamless workflow, update relevant changes and address any operational issues</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resources</li>"},{"text":"What Will You Need","content":"<li>Minimum 1 year of working experience&nbsp;</li><li>End to end the problem-solving mindset that can work well with stakeholders&nbsp;</li><li>Basic data analytics capability, having capability in SQL is a plus</li><li>Experience in Growth, Product Management, and Data team is a plus</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders&nbsp;</li><li>Open to acquiring new skills and taking on diverse projects</li>"}],"text":"Ads Ops Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.</div>","descriptionBodyPlain":"About the Role\n\nAs an Ads Ops Associate, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of executing day-to-day operations of our merchant campaigns, ensuring efficiency, productivity, and smooth workflow. This role involves a mix of administrative tasks, process improvements, and operational support. The ideal candidate is detail-oriented, has strong analytical skills, and can thrive in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908","applyUrl":"https://jobs.lever.co/GoToGroup/94f85d13-6fe6-43a8-96c8-4898ab75d908/apply"},{"additionalPlain":"About The Team\nArea CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales & analytics team) in the designated Areas.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Area CE Associate will play for marketing strategy in Gojek Regions. He/she will report to the appointed Area Head. He/she will regularly coordinate with the all team (operations, sales &amp; analytics team) in the designated Areas.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Semarang","team":"Central West Java Regions","allLocations":["Semarang"]},"createdAt":1720592465974,"descriptionPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","id":"f1bdce17-4ab5-49ab-9dbc-6d96a5619846","lists":[{"text":"What You Will Do","content":"<li>Support Area Head to drive consumer engagement focus areas in terms of Visibility &amp; Partnership which will deliver POI domination, POS merchants branding, standard package that will deliver Area target completed orders and active users</li><li>Managing all day to day marketing executional activities from all areas needed to deliver the consumer engagement plans. e.g. contract, PO, invoice, etc.</li><li>Ensure all consumer engagement activities in areas are delivered with a given standard of accuracy, completeness, timeliness as per the standard package and local initiatives</li><li>Externally supervise vendors/daily workers in executing merchant branding and POI domination on a regular basis</li><li>&nbsp;Internally work with direct responsibility to deliver area executions and targets by executing events, exhibits, and other activities</li><li>Good with data to develop and execute clear integrated strategies of digital marketing with clear metrics and excellent results</li><li>Responsible for setting the integrated communications plan and ensuring consistency of messaging and brand communications. Working closely with the sales, government relations, and operations team</li>"},{"text":"What This Role Needs","content":"<li>At least 2&nbsp; years of working experience in Marketing/Sales</li><li>Good understanding of local knowledge</li><li>Strong analytical and planning skills</li><li>Good communication and presentation skills</li><li>Excellent problem-solving skill with the ability to play it well independently and in a team</li><li>Good collaboration with compassion and proactiveness</li><li>Agile and fast in thinking and execution</li><li>Have exposure of working at a top global FMCG company would be a plus point</li>"}],"text":"Area CE Associate - Semarang - #10227","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">You will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.</span></div>","descriptionBodyPlain":"About The Role\nYou will be responsible for developing Gojek products by creating and implementing strategic marketing plans across various touch points namely visibility, partnership, and digital to name a few. You will also be responsible for the marketing funnel of Gojek products across the representative Area, aligned with the headquarter initiatives. You will work closely with the CE, Marketing, and cross functional team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846","applyUrl":"https://jobs.lever.co/GoToGroup/f1bdce17-4ab5-49ab-9dbc-6d96a5619846/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720169838701,"descriptionPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><span style=\"font-size: 10pt\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","lists":[{"text":"What you will do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;</li><li>driver acquisition management</li><li>driver engagement management (loyalty &amp; retention and safety &amp; performance training)&nbsp;</li><li>driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant)</li><li>driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li><div><br></div>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Having good understanding about supply and demand planning</li><li>Having experience in managing a small team (&gt; 3 members)</li><li>Having good communication skills and good attention to detail and routine activities</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Able to handle communication in community or mass conflict&nbsp;</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written in English</li>"}],"text":"Area Operations Manager - Bekasi","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb","applyUrl":"https://jobs.lever.co/GoToGroup/1ddf8980-6a4b-4b3d-a662-ddf9ee7148fb/apply"},{"additionalPlain":"About the team \n\nArea Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the team </b></div><div><br></div><div><span style=\"font-size: 16px\">Area Operations Manager (AOM) will work within direct command of Area Head and matrix collaboratively with the regional operations team on some projects. You will lead the Operations team consisting of Operations Supervisor and Staffs attached to your area. You play a pivotal role to improve the quality life of drivers and at the same time ensuring our consumers are easily helped by providing sufficient supply. Though everyday will be very challenging managing the entire operations in the area but you feel great satisfaction as you are directly creating a social impact.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Depok","team":"-","allLocations":["Depok","Bogor"]},"createdAt":1713768982209,"descriptionPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","id":"18674f77-24b2-46a4-86bb-7b5e7fe71f2c","lists":[{"text":"What You Will Do:","content":"<li>Accountable for day-to-day operations monitoring (2W and 4W) including:&nbsp;&nbsp;Driver acquisition management, Driver engagement management (loyalty &amp; retention and safety &amp; performance training), Driver exit (i.e. drivers suspension, etc.) management and inventory management (driver attributes and driver warrant), driver income through driver expenses reduction and providing alternative income (i.e. Swadaya, Promo Go)&nbsp;</li><li>Collaborate with Area Head for day-to-day escalated issues around driver services</li><li>Collaborate with Sales and Consumer Engagement team to achieve shared target in Area level</li><li>Collaborate with Public &amp; Government Relation team and Local Government that related to operations, e.g. Dishub</li><li>Responsible for end to end processes channel walk in center (Driver Support Unit) in the area</li><li>Ensure SOP and legal compliances in the specific area</li><li>Manage and evaluate all programs related with generating more high quality drivers in the region</li><li>Support Regional Operations Head in product changes roll out and other strategic implementation in the region</li>"},{"text":"What You Will Need","content":"<li>At least 5 years experience in operations/ supply/ demand generation, preferably at the managerial level and from Multi National Company</li><li>Having strong analytical thinking, insights generating, and complex problem solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Good understanding about supply and demand planning</li><li>Prior experience in managing team (&gt; 3 members)</li><li>Good communication skills and good attention to detail and routine activities</li><li>Ability to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Capability to handle communication in community or mass conflict&nbsp;</li><li>Proficiency in English both spoken and written</li>"}],"text":"Area Operations Manager (Bogor Depok)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.</span></div>","descriptionBodyPlain":"About The Role\n\nAs Area Operation Manager, you will be an integral player in the Indonesia Region team. Focus on managing the supply, you will handle full operational activities related to our driver-partners, including operations monitoring (that include acquisition, onboarding, engagement, and driver welfare), ensure the SOP is in compliance with area regulations, and collaborate with various stakeholders in ensuring the full capacity of the performances of our driver-partners in efforts to providing the best experience for our drivers.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c","applyUrl":"https://jobs.lever.co/GoToGroup/18674f77-24b2-46a4-86bb-7b5e7fe71f2c/apply"},{"additionalPlain":"About The Team\n\nOur Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners. \n\nOne of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team. \n\nOur team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Area Operations team is a big family spread out across multiple regions in Indonesia. Working alongside the Product team, we are predominantly concerned with all things to do with our driver-partners - their experiences using our services, their life cycle, their engagement with the company, and growing our driver partner family in the district, just to name a few things. We also oversee the supply within Gojek, including creating detailed business analyses, outlining problems, and developing solutions for our driver-partners.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">One of the biggest challenges our team has had to face has undoubtedly been maintaining a high level of engagement with our driver-partners amidst the COVID-19 pandemic. To ensure our driver-partner ties remain strong with the company, we introduced online meet-ups and forums with our driver-partners where they can openly discuss their questions, concerns, and experiences directly with our team.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team genuinely enjoys what we do since we get to see the impact of our work reflected in our driver-partners' everyday lives on the field. We're a fun group made up of avid readers, amateur gamers, Netflix watchers, K-pop listeners, and (guilty🙈) reality show watchers. We're also big foodies, since we're spoiled for choice here in Indonesia (food recommendations are always welcome!).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Direct Contract","department":"ODS - Regions","location":"Tangerang","team":"-","allLocations":["Tangerang"]},"createdAt":1716869065162,"descriptionPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","description":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","id":"8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","lists":[{"text":"What You Will Do","content":"<li>List, identify, and propose solutions to our driver partners' problems on the field and ensure their concerns are heard by following up with them</li><li>Manage offline engagement (i.e. 'kopdar') as our way to inform, reach, and engage with driver partners</li><li>Ensure all engagement programs are well executed and implemented</li><li>Handle driver support unit according to agreed operating office hours</li><li>Support implementation of Gojek's policies/programs by managing these changes</li><li>Propose activities/programs to engage our driver partners</li><li>Monitor personal metrics of engagement with driver partners, and propose solutions to increase the level of engagement</li>"},{"text":"What You Will Need","content":"<li>A Bachelor's degree (fresh graduates are welcome to apply!)</li><li>At least 1 year of experience in supply chain, preferably at a multinational company</li><li>Strong analytical thinking and problem-solving skills to effectively resolve driver-related issues</li><li>Strong interpersonal skills in order to cater and build relationships with various stakeholders</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Sharp attention to detail to increase productivity and reduce the likelihood of errors</li><li>Excellent planning and organizational abilities to ensure the area team is on track to achieve its goals</li><li>An understanding about/familiarity with the Tangerang region</li>"}],"text":"Area Operations Staff","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.</span></div>","descriptionBodyPlain":"About The Role\n\nIf you’re looking to be a part of a dynamic, highly-analytical team who enjoys creating strategy based on available data, look no further. As our Area Operations Staff for the Indonesia Region team, you will be handed the reins in overseeing the supply management for Gojek. Along with the district team, you will be in charge of the operational driver spectrum within the district level, which includes balancing supply and demand (BCR), utilizations, driver acquisitions, driver engagements, and solving driver problems on the field. Working closely with the Regional Strategy team, you will even get to localize the HQ strategy that matches the nature of the district. Perhaps the most meaningful of all: your efforts will work to enhance the lives and livelihoods of our driver partners in the region, providing them with the attention, experience, and opportunities they deserve.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2","applyUrl":"https://jobs.lever.co/GoToGroup/8238e5a5-b5e0-45a4-8e01-aef39e92b3a2/apply"},{"additional":"","additionalPlain":"","categories":{"department":"ODS - Regions","location":"Balikpapan","team":"Emerging Market","allLocations":["Balikpapan"]},"createdAt":1719223321521,"description":"","descriptionPlain":"","id":"95ee9a06-a46d-43a2-a8e7-003de776404d","lists":[{"text":"What you will do:","content":"<li>Handle all the driver community, marketing, and driver care responsibilities on areas level and channel walk in center on each area;</li><li>Ensure problem solving according to agreed process &amp; based on standard operational procedure;</li><li>Manage driver’s problems and empowerment;</li><li>Coordinate with Area Operations Manager for day-to-day escalated issues around driver service and customer service to manage service time, driver and customer satisfaction;</li><li>Developing the marketing strategy for the company in line with company objectives;</li><li>Conceptualizes events, exhibits and other below the line marketing based on the marketing plan, and evaluate the effectiveness of all marketing activities;</li><li>Maintain effective internal communications to ensure that all relevant company functions are kept informed of marketing objectives.</li>"},{"text":"What you will need:","content":"<li>Having a minimum of 3 years experience in related fields;</li><li>Bachelor degree from top university any well-known universities from each region with GPA &gt; 3.2 or equivalent;</li><li>Passionate about community development, having relevant previous experience would be preferred;</li><li>Experience launching community initiatives (building an online forum, launching an ambassador program, creating an event series, etc.);</li><li>Ability to identify and track relevant community and market metrics;</li><li>Excellent verbal communication and writing skills;</li><li>Having a basic of data analytics;</li><li>Willing to relocate to a selected area.</li>"}],"text":"Area Operations Supervisor - Balikpapan","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d","applyUrl":"https://jobs.lever.co/GoToGroup/95ee9a06-a46d-43a2-a8e7-003de776404d/apply"},{"additionalPlain":"About the team\n\nThis position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team. \n","additional":"<div><b>About the team</b></div><div><br></div><div>This position will be based in Makassar and work closely with the Sales team who manage Kalimantan and Sulampa. But no limit interaction with other streams team such as Operations and Consumer Engagement and in wider with Region Emerging Market team.&nbsp;</div>","categories":{"department":"ODS - Regions","location":"Makassar","team":"Emerging Market","allLocations":["Makassar"]},"createdAt":1721716492787,"descriptionPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","description":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","id":"20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","lists":[{"text":"What Will You Do","content":"<li>Develop and implement procedures for effective sales support administration;</li><li>Monitor and analyze sales support team performance to identify areas for improvement and implement strategies to increase efficiency;</li><li>Ensure all sales inquiries and issues are addressed promptly and accurately, with a focus on improving merchant satisfaction &amp; topline sales metrics;</li><li>Coordinate with the merchant sales team to streamline sales processes and remove obstacles in the sales cycle;</li><li>Execute GoFood onboarding timely &amp; ensure that there is no backlog</li><li>Able to understand KYC follow up reasons based on FAQ and able to know when to escalate</li><li>Collaborate with other departments to ensure sales and marketing strategies are aligned and support the overall goals of the organization;</li><li>Assist in the development and implementation of sales policies and practices that drive sales effectiveness.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree in Business Administration, Marketing, or a related field;</li><li>Minimum of 3 years of experience in sales support, account management, customer service, sales-marketing administration related or a supervisory role within a sales-focused organization;</li><li>Strong customer/merchant partner focus and project management skills preferred;</li><li>Has data reporting skills, preferred both Bahasa Indonesia and English;</li><li>Strong analytical and problem-solving abilities by utilizing e.g. Google Sheet, etc;</li><li>Detail and deadline oriented;</li><li>Strong stakeholder management and cross-functional collaboration;</li><li>Able to adapt in a fast-changed environment.</li>"}],"text":"Area Sales Support Supervisor (Sulampa)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>You will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction &amp; sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.</div>","descriptionBodyPlain":"About the Role\n\nYou will play a pivotal role in to support Sales team in Area Sulawesi, Maluku, and Papua, ensuring the smooth operation of the merchant department, and enhancing merchant satisfaction & sales. This individual is responsible for coordinating merchant sales activities, addressing merchant inquiries, maintaining merchant sales records, and fostering relationships with key stakeholders to drive sales effectiveness and organizational success.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450","applyUrl":"https://jobs.lever.co/GoToGroup/20ac3ffc-cda7-4b2e-b0c2-dda2cc52d450/apply"},{"additionalPlain":"About The Team\n\nOur tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!  \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">Our tax team, a division of the HoldCo CFO office, mainly professionals based in Indonesia, consists of several sub-divisions of tax functions working alongside the finance and business operations. We are predominantly concerned with ensuring all technical taxes have been appropriately followed and maintain a high level of compliance. If you are passionate about tax and finance, whilst looking for a fun dynamic environment, then we are your people!&nbsp;&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697204557563,"descriptionPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","description":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","id":"56966262-038f-497f-84c1-f360a9440c55","lists":[{"text":"What You Will Do","content":"<li>Manage tax compliance matters; including preparation of monthly and annual tax calculation/payment/returns, i.e. WHT, VAT, CIT)</li><li>Manage and advise day-to-day business initiatives including decisive actions toward dynamic business products</li><li>Manage and handle restructuring projects independently with supervision from the AVP of Tax</li><li>Able to communicate and align with relevant stakeholders within the group</li><li>Monitoring any tax regulation updates, identifying relevant business areas that may be impacted, and planning the risk mitigation strategy</li><li>Able to support the litigation process and assessment of risks</li><li>Able to support the advocacy initiatives within the relevant external organizations.</li>"},{"text":"What You Will Need","content":"<li>S1 Bachelor of Economics (majoring in accounting or corporate finance) or Bachelor of Social Finance (Majoring in Fiscal Administration) </li><li>Minimum 5 years of working experience in the taxation field</li><li>Strong interpersonal, analytical, communication, and presentation skills with advanced command of written and spoken English</li><li>Strong technical skills in tax, accounting, and corporate finance</li><li>Ability to work in a fast-paced, rapidly changing, and high-growth environment</li><li>Able to work independently and in a team</li>"}],"text":"Assistant Tax Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Team</b></div><div><br></div><div>As Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.</div><div>This role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment.&nbsp;</div><div>The candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.</div>","descriptionBodyPlain":"About The Team\n\nAs Assistant Tax Manager, you will hold an important role within the Group Tax team that directly impacts GoTo Group’s stakeholders. In this role, you will get to take care of tax compliance matters and also provide tax advisory for the GoTo Group. The GoTo Finance Shared Service team will be your companions during this ride.\nThis role will support and significantly impact the Group position and implementation of business operations as it will safeguard and ensure that each arrangement has considered the appropriate tax treatment. \nThe candidates will be required to catch up with the variety of businesses in the GoTo group and understand the commercial flow, establishing communication with all relevant stakeholders within the group.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55","applyUrl":"https://jobs.lever.co/GoToGroup/56966262-038f-497f-84c1-f360a9440c55/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721353652294,"descriptionPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","description":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","id":"325ee617-30f3-41c1-a022-6577bd82faf0","lists":[{"text":"What You Will Do","content":"<li>Collecting and importing data from various sources into databases.</li><li>Cleaning and preprocessing data to ensure accuracy and consistency.</li><li>Analyzing datasets to identify trends, patterns, and insights.</li><li>Creating and maintaining data visualizations and dashboards.</li><li>Generating regular and ad-hoc reports for stakeholders.</li><li>Collaborating with team members and stakeholders to understand data needs and requirements.</li><li>Monitoring data quality and integrity, addressing any discrepancies.</li><li>Utilizing programming languages (e.g., SQL, Python) and tools (e.g., Sheet) for data manipulation and analysis.</li>"},{"text":"What You Will Need","content":"<li>Technical Skills: Proficiency in SQL, Python, and Sheet for data manipulation and analysis.</li><li>Analytical Skills: Strong analytical and problem-solving skills to interpret data and create actionable insights.</li><li>Reporting Tools: Familiarity with tools for generating reports, such as Sheet, Metabase, or Looker Studio.</li><li>Communication Skills: Ability to communicate findings and insights effectively to non-technical stakeholders..</li>"}],"text":"Business Analyst - GoPay","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>Scope</b></div><div><span style=\"font-size: 10pt;\">The candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.</span></div><div><br></div><div><b>6 Months Challenge</b></div><div><span style=\"font-size: 10pt;\">Biggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.</span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div>","descriptionBodyPlain":"Scope\nThe candidate will collect, process, and perform statistical analyses on large datasets. Key responsibilities include data cleaning, visualization, and report generation. Proficiency in SQL, Python, and Sheet is required. The Data Analyst will interpret data to identify trends and insights, aiding in informed decision-making. Collaboration with stakeholders to understand business requirements and ensure data-driven strategies align with organizational goals is essential.\n\n6 Months Challenge\nBiggest challenge will be understanding the complex data architecture and systems unique to both GoPay and Gojek. Candidates will need to quickly familiarize themselves with existing datasets, data sources, and data presentation tools. Additionally, they must build strong relationships with various stakeholders to accurately interpret business requirements and deliver actionable insights. Balancing these technical and interpersonal aspects while delivering high-quality analyses under tight deadlines will be crucial.\n\nAbout the Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0","applyUrl":"https://jobs.lever.co/GoToGroup/325ee617-30f3-41c1-a022-6577bd82faf0/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716278898371,"descriptionPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","description":"<div><span style=\"font-size: 16px\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","id":"2242125a-7155-4353-bc79-473d237d6808","lists":[{"text":"What You WIll Do","content":"<li>Be the expert in using data to measure and analyze business performance.</li><li>Explore business issues/opportunities, uncover insights and/or identify targeted areas for business growth.</li><li>Lead new data analytics capability rollouts and/or data-led initiatives throughout organization.</li><li>Monitor key metrics and alert the business on potential issues.</li><li>Analyze operational efficiency and build business models to guide decision-making.</li><li>Design market/business intelligence reports and performance measurement dashboards to share with senior management.</li><li>Able to analyze business performance following the analysis framework.</li><li>Able to create reports/ dashboards individually.</li><li>Collaborates with business stakeholders to gather requirements and deliver actionable insights.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Statistics, Business Administration, or a related field.</li><li>2-5 years of experience in a BI or analytics role.</li><li>Proficiency in SQL and database management systems like MySQL, SQL Server, or Oracle.</li><li>Advanced knowledge of data modeling and data warehousing concepts.</li><li>Strong understanding of business processes and the ability to translate business requirements into technical solutions.</li><li>Familiarity with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Experience with BI reporting tools and dashboard development.</li><li>Proven ability to work with cross-functional teams and manage stakeholders.</li><li>Familiarity with business operations in the field.</li>"}],"text":"Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. </span></div>","descriptionBodyPlain":"We are seeking a skilled Business Intelligence Analyst, where you'll be instrumental in utilizing data to measure business performance, uncover growth opportunities, and monitor key metrics. Lead the rollout of new analytics capabilities and initiatives throughout the organization, while also analyzing operational efficiency and constructing business models to guide decision-making. Your responsibilities will include designing market/business intelligence reports and performance measurement dashboards for senior management, as well as supporting senior team members in data-related tasks such as querying databases and creating visualizations. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808","applyUrl":"https://jobs.lever.co/GoToGroup/2242125a-7155-4353-bc79-473d237d6808/apply"},{"additionalPlain":"About The Team\nWe foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">We foster a culture where everyone is encouraged to freely express their thoughts and feedback, valuing each member’s unique perspective. Our obsession with detail ensures that we meticulously analyze and refine our work to achieve the highest standards of quality. Collaboration and open communication are at the heart of our operations, enabling us to improve and solve complex problems effectively.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119647983,"descriptionPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><b style=\"font-size: 16px\">Job Scope</b></div><div><span style=\"font-size: 16px\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px\">6 Months Challenge</b></div><div><span style=\"font-size: 16px\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","id":"9a8977f6-ea32-40e0-bb09-d3330c40d056","lists":[{"text":"What You Will Do","content":"<li>Monitor performance metrics and adjust processes as needed</li><li>Build relationships with stakeholders to support process optimization initiatives</li><li>Leverage technology to automate tasks and improve accuracy</li><li>Focus on enhancing customer experience in building automated support processes</li><li>Ensure high-quality service delivery to customers</li><li>Implement changes to streamline workflows and enhance efficiency</li>"},{"text":"What This Role Needs","content":"<li>At least 5 years working experience in related field</li><li>Strong analytical and problem-solving skills</li><li>Experience in process optimization and workflow management</li><li>Proficiency with automation tools and technology</li><li>Excellent communication and coordination abilities</li><li>Ability to prioritize tasks and manage time effectively</li><li>Knowledge of customer experience best practices</li><li>Familiarity with fintech industry standards and trends</li><li>Collaborative mindset to build relationships with stakeholders</li>"}],"text":"Business Operations Analyst (Trust and Safety) - GoPay - #10311","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><b style=\"font-size: 16px;\">Job Scope</b></div><div><span style=\"font-size: 16px;\">The candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.</span></div><div><br></div><div><b style=\"font-size: 16px;\">6 Months Challenge</b></div><div><span style=\"font-size: 16px;\">The biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.</span></div>","descriptionBodyPlain":"About The Role\nJob Scope\nThe candidate will analyze and optimize workflows, implement process improvements, and ensure high-quality service delivery to our customers. Responsibilities include monitoring performance, coordinating between stakeholders, and leveraging technology to automate tasks and enhance data accuracy.\n\n6 Months Challenge\nThe biggest challenge in the first six months will likely be gaining a thorough understanding of the existing business processes and identifying key areas for improvement. This includes learning the technology stack, integrating seamlessly with various departments, and implementing changes without disrupting ongoing operations. Additionally, the candidate will need to build relationships with stakeholders to ensure collaboration and support for process optimization initiatives aimed at enhancing customer service quality.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056","applyUrl":"https://jobs.lever.co/GoToGroup/9a8977f6-ea32-40e0-bb09-d3330c40d056/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264950378,"description":"","descriptionPlain":"","id":"73e71b86-d53f-4841-92ec-4bd09a0ef479","lists":[{"text":"What You Will Do","content":"<li>explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across the Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs..</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Data Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479","applyUrl":"https://jobs.lever.co/GoToGroup/73e71b86-d53f-4841-92ec-4bd09a0ef479/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716265340466,"description":"","descriptionPlain":"","id":"36d71dff-c9ac-44b8-b870-f74d941bd7d3","lists":[{"text":"What You Will Do","content":"<li>Design and implement complex data solutions, architecting data systems, and driving technical initiatives.</li><li>Optimize data infrastructure for performance, scalability, and reliability - working with large-scale data volumes &amp; distributed systems.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues, as&nbsp; well as delivering solutions to meet business needs.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Design, build, and optimize data pipelines, ETL processes, and data infrastructure in the field.</li><li>Provide technical guidance and support to ensure the successful delivery of data projects, including troubleshooting and resolving technical challenges.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>5+ years of experience in data engineering, software engineering, or a similar role.</li><li>Expertise in programming languages such as Python, Java, or Scala.</li><li>Advanced knowledge of SQL, database management systems, and data warehousing concepts.</li><li>Extensive experience with big data technologies and distributed systems.</li><li>Proven track record of designing and implementing complex data pipelines and ETL processes.</li><li>Deep understanding of cloud-based data technologies and best practices.</li><li>Leadership abilities to mentor junior team members and lead technical initiatives.</li><li>Strong problem-solving and troubleshooting skills.</li><li>Ability to communicate technical concepts effectively to both technical and non-technical stakeholders.</li>"}],"text":"Data Engineer Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3","applyUrl":"https://jobs.lever.co/GoToGroup/36d71dff-c9ac-44b8-b870-f74d941bd7d3/apply"},{"additionalPlain":"About the Team\n\nThe Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience. \nAs a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Supply Operations team is a unit within the broader Gojek Singapore team that leads our vision, strategy, and execution in the Singapore market. Supply Operations is all about running our business on the ground and helping our driver-partners get the most out of the Gojek platform. The team is responsible for achieving driver growth, experience, retention, and profitability targets, making sure that we offer our drivers and users a delightful experience.&nbsp;</div><div>As a team, we're concerned not only with the growth of the company but also each other's personal growth and well-being. We’re all about finding the right balance between work and life, and lately, we’ve been bonding over our shared love for boba and workouts. Whether it’s after-work sunset jogs or friendly games of badminton, we prioritize team bonding and well-being alongside company success.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1717749466111,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","description":"<div><span style=\"font-size: 10pt\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","id":"d93a7524-8ab9-4499-9f04-0876fcafa529","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain performance management dashboards and visualizations.&nbsp;</li><li>Provide regular analysis on operational performance metrics including transactions, conversion rate, lead quality, cost efficiency, retention, and KPI tracking to guide decision-making and devise proactive solutions.&nbsp;</li><li>Collaborate across teams to drive Operational Excellence (OPEX) and Continuous Improvement Process (CIP) initiatives, identifying growth opportunities for product, customer, driver, and optimization.&nbsp;</li><li>Support senior management with clear and concise presentations of complex data sets for informed decision-making.&nbsp;</li><li>Build, automate, and enhance reporting, data logging, and data pipelines for availability, integrity, accuracy, and reliability, ensuring security and compliance.&nbsp;</li><li>Assist in report compilation, issue investigation, and liaison with internal and external stakeholders for regulatory compliance.</li>"},{"text":"What You Will Need","content":"<li>Bachelors' Degree in Economics, Computer Science, Engineering, Mathematics or Statistics.&nbsp;</li><li>Minimum 5 years experience with 3+ years of relevant experience in analytics and product/process improvement.&nbsp;</li><li>Proficient in analyzing large datasets and translating quantitative findings into actionable insights.&nbsp;</li><li>Excellent understanding of analytics, computational modeling, business needs analysis, data visualization, and stakeholder management.&nbsp;</li><li>Resilience and initiative in a fast-paced, dynamic environment&nbsp;</li><li>Proficient in SQL; experience in BI tools such as Tableau, Metaforce, Python or Looker is a plus&nbsp;</li><li>Prior experience demonstrating strong stakeholder engagement and vendor management skills is a plus</li>"}],"text":"Data Operations Analyst","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.</span></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that aims to improve the Gojek experience and engage more users, look no further. As the Data Operations Analyst within our Operations team, you’ll lead the design and implementation of scalable analytics solutions, providing actionable insights and driving continuous improvement in data operations. Working closely with multiple functions, you'll delve into local market insights to deliver timely, accurate, and actionable analytics, fueling growth and optimizing data pipelines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529","applyUrl":"https://jobs.lever.co/GoToGroup/d93a7524-8ab9-4499-9f04-0876fcafa529/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Internship","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719909376581,"descriptionPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","id":"816f2d4c-5ff6-4e83-8697-9c25df599409","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li><b>Fresh Graduates </b>from computer science, mathematics, or statistics<b>&nbsp;</b>(Students on final semester are also preferred)</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Data Scientist Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure </span></div><div><br></div><div><b>About the Team</b></div><div><span style=\"font-size: 10pt;\">GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a data scientist intern to join our Data Science team at GoPay - you will create models which help grow the customer base and transactions in GoPay. You will work closely with the business, product and engineering stakeholders to identify and solve some of the most challenging business problems in the payments space. You will have the opportunity to work in a fast-paced environment in a highly cross-functional team and leverage our robust data infrastructure \n\nAbout the Team\nGoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc.) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409","applyUrl":"https://jobs.lever.co/GoToGroup/816f2d4c-5ff6-4e83-8697-9c25df599409/apply"},{"additionalPlain":"Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.\n","additional":"<div><span style=\"font-size: 10pt\">Our team is a mix of folks from different backgrounds like marketing, business, engineering, product, finance design, and more. We're spread out across Indonesia, India, Singapore, and Vietnam. In the Transport and Logistics division at Gojek, we're all about keeping things running smoothly from the inside out. We focus on fueling the business by solving challenges, generating demand, optimizing supply, and running effective promotions and campaigns to drive revenue growth. In essence, we ensure smooth operations and keep the business moving forward. Our primary role involves developing and overseeing business strategies for the broader Gojek market.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718963848611,"descriptionPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","description":"<div><span style=\"font-size: 9pt\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","id":"5d07cd21-8826-4de7-9ad4-15909a0c5c37","lists":[{"text":"What you will do","content":"<li>Devise and implement tailored digital marketing strategies for GoRide, GoCar, GoSend, and GoShop</li><li>Analyze market trends to identify growth opportunities and refine strategies accordingly</li><li>Collaborate cross-functionally to ensure alignment with business goals</li><li>Monitor and evaluate campaign performance to drive optimization</li><li>Stay updated on industry trends and technologies to drive innovation</li><li>Manage relationships with external partners and agencies to support initiatives</li><li>Contribute to overarching marketing strategies and brainstorming sessions.</li><div><br></div>"},{"text":"What you will need","content":"<li>3+ years of digital marketing experience</li><li>Proficiency in digital marketing tools and platforms such as Google Adwords, Meta, TikTok Ads, Google Analytics &amp; Data Studio/Looker</li><li>Strong analytical, communication, and problem-solving skills</li><li>Bachelor's degree in Marketing, Communications, or related field</li><li>Fluency in English. </li><div><br></div>"}],"text":"Digital Marketing Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.</span></div>","descriptionBodyPlain":"As the Digital Marketing Specialist for Gojek's market, based in Indonesia (Jakarta), you'll be pivotal in devising and executing strategic digital marketing campaigns to bolster brand presence and drive user acquisition. Leveraging your expertise in digital platforms and consumer behavior, you'll craft compelling channel strategy and oversee its dissemination across various platforms. Your analytical prowess will be instrumental in assessing campaign performance and optimizing strategies for maximum impact. This role offers a unique opportunity to spearhead marketing initiatives in a dynamic and rapidly evolving market landscape.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37","applyUrl":"https://jobs.lever.co/GoToGroup/5d07cd21-8826-4de7-9ad4-15909a0c5c37/apply"},{"additionalPlain":"The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">The Service Excellence team, an integral part of the Gojek Singapore team, is dedicated to providing end-to-end support for our valued driver-partners and customers. Collaborating closely with operations and product teams, we aim to ensure a smooth experience for users at every stage, continuously seeking improvement. Our relentless pursuit of improvement drives us to constantly innovate and refine our processes. Furthermore, as a cohesive unit, we prioritize not just the company's advancement, but also the individual development, welfare, and unity among our team members.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1722240835278,"descriptionPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","description":"<div><span style=\"font-size: 9pt\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","id":"eb38692a-8133-4cd2-a793-f5d75ee8841a","lists":[{"text":"What You Will Do","content":"<li>Accountable for leading the driver onboarding and support team, ensuring a quick and seamless experience for driver-partners at the GoHub</li><li>Management of day-to-day operations of the team, including communications and KPI performance management</li><li>Drive results through strong internal and external collaboration to improve the quality and efficiency of the team</li><li>Support &amp; drive operational requirements, to achieve and exceed team productivity and service level targets</li><li>Responsible for the design, deployment and maintenance of processes arising from new product launches and enhancement to existing process flows</li><li>Understand reporting needs and provide appropriate data analysis on performance metrics for stakeholders</li><li>Work with relevant stakeholders to identify and prioritize improvement initiatives and other cross-functional projects</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience as an operations manager in a contact center / frontline customer service operations</li><li>Experience in managing teams, motivating, coaching and inspiring team members to achieve excellent customer experience</li><li>Address conflicts and interpersonal issues within the team professionally and diplomatically</li><li>Ability to make informed decisions under pressure, considering both short-term and long-term implications</li><li>Keen eye for detailed process steps &amp; identification of gaps/opportunities</li><li>Strong stakeholder and project management capabilities</li><li>Efficiently manage time, resources, and priorities to ensure productivity and meet deadlines</li><li>Keep customer needs in mind when making decisions and managing operations</li><div><br></div>"}],"text":"Driver Care Lead, Hub Operations","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.</span></div>","descriptionBodyPlain":"If you thrive in a fast-paced, dynamic setting and aim to refine your skills in managing stakeholders, this opportunity is perfect for you. As the Driver Care Lead, you'll oversee the day-to-day activities, metrics, and performance of our frontline support and onboarding operations. Additionally, you'll play a crucial role in standardizing operating procedures within the Care Operations team and pinpointing areas for enhancement using both quantitative and qualitative assessments. This position will also require strong analytical skills and collaboration with various stakeholders to enhance the support experience. Working closely with the Service Excellence team, you'll contribute to Gojek's mission of delivering exceptional experiences to all users.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a","applyUrl":"https://jobs.lever.co/GoToGroup/eb38692a-8133-4cd2-a793-f5d75ee8841a/apply"},{"additionalPlain":"About the Team\n\nWe are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nAlong with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1714628452648,"descriptionPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px\">&nbsp;</span></div><div><span style=\"font-size: 16px\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","id":"dfe98505-36d8-4467-aa36-df8599ab69d8","lists":[{"text":"What You Will Do","content":"<li>Assess and manage team performance through staff meetings, one on ones, and quarterly assessments</li><li>Mentor your engineers to ensure their growth and engagement in the team, evaluate team workload and develop a staffing plan, and assign projects and balance workload to ensure continuous delivery and higher predictability</li><li>Serve as primary interface to staffing team, creating job descriptions, identifying sources for candidates, conducting interviews and shepherding candidates through the process</li><li>Lead a team of Software Engineers focused on improving velocity and impact across Gojek’s diverse project areas and platforms</li><li>Become a partner to Product Managers on deciding vision, strategy and OKRs</li><li>Provide technical expertise throughout the product life cycle including design, implementation, and delivery of scalable build/test/release infrastructure</li>"},{"text":"What You Will Need","content":"<li>Having at least 8 years of relevant software development experience preferably with experience in data products, also at least 2 years of leading and mentoring an engineering team to success</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, TDD and Test Engineering, and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate dependency risks</li><li>Ability to review the code and ensure code maintainability as part of new product enhancements.</li>"},{"text":"Bonus Points If","content":"<li>Understanding in data modeling for data warehouse, relational database, and non-relational database</li><li>Understanding in batch and stream data pipeline; Beam, Flink, Spark</li>"}],"text":"Engineering Manager - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 16px;\">&nbsp;</span></div><div><span style=\"font-size: 16px;\">You will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies and witness and solve the challenges that come with rapid scaling.    \n \nYou will be on the streaming team responsible for working on 3 products. The next-gen self-serve real-time data transformation platform, Kafka to multiple sink lightweight and DIY product and dynamic schema registry. Since most of Gojek across Data Science and Engg use this product and rely on them, the responsibility increases to provide high-quality products.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8","applyUrl":"https://jobs.lever.co/GoToGroup/dfe98505-36d8-4467-aa36-df8599ab69d8/apply"},{"additionalPlain":"About the Team\n\nThe Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Enterprise Security team is a tight knit, diverse, and collaborative team full of strong-minded individuals that are focused on problem-solving. We welcome and encourage everyone to speak their mind and engage in candid discussions to solve interesting challenges that we’re dealing with on a day-to-day basis.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721370013113,"descriptionPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","id":"178ba514-705f-4f0b-9e48-fe917c47a95b","lists":[{"text":"What You Will Do","content":"<li>Continuously monitor, review, maintain, and improve security controls that are used to secure GoTo enterprise IT systems and SaaS services;</li><li>Review and implement initiatives to improve the security posture of GoTo enterprise IT systems and SaaS services;</li><li>Perform security hardening on GoTo IT systems and SaaS services;</li><li>Support the remediation of relevant security issues relevant to GoTo corporate IT systems and SaaS services;</li><li>Provide answers and recommendations to security-related questions, queries, and requests related to GoTo enterprise IT systems and SaaS services;</li><li>Develop, review, and improve technical documentation and reports relevant to the security controls used by GoTo corporate IT systems and SaaS services.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, networking, and general security concepts (a bachelor's degree or higher is a plus).</li><li>At least 5 years of experience in cyber security, preferably with hands-on experience in implementing and maintaining the security of enterprise grade IT systems and SaaS services, e.g., Google Workspace, Microsoft 365, Slack, SAP, or Atlassian;</li><li>Proven hands-on experience in the configuration and troubleshooting of enterprise security solutions, e.g., EDR, MDM, DLP, Firewall, and/or SASE;</li><li>Proven hands-on experience in the management and security of enterprise collaboration tools such as Google Workspace, Microsoft 365, or Lark;</li><li>Coding and scripting skills especially for automation is highly desired;</li><li>Ability to develop clear and concise documentation and reports.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Enterprise Information Security Engineer Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users.&nbsp;</div><div><br></div><div>The role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.</div><div><br></div><div>The role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.</div>","descriptionBodyPlain":"About the Role\n\nThe enterprise information security engineer is responsible for independently improving and maintaining the security of Enterprise IT systems and SaaS services used by GoTo corporate users. \n\nThe role is required to independently collaborate with various security, IT, and engineering teams to continuously monitor, review and if required improve the security of GoTo enterprise IT systems and SaaS services. He/she is required to independently identify possible security issues and then subsequently identify and drive the implementation of security improvements to maintain the GoTo security posture.\n\nThe role will also act as a subject matter expert and provide security recommendations as well as answer security-related queries for GoTo users and teams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b","applyUrl":"https://jobs.lever.co/GoToGroup/178ba514-705f-4f0b-9e48-fe917c47a95b/apply"},{"additionalPlain":"About The Team\n\nCost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Cost Management team is part of the GoTo Financial Finance team – Financial Controllers Function, located in Jakarta, Indonesia. We aim to be the Business partner for all the functional and product groups in the GoTo Financial, by supporting the stakeholders as they manage operations and drive business decisions. We work in a team that is committed to providing robust financial analysis, challenging operational efficiency, and continuous improvement in this fast-growing business environment.</div>","categories":{"commitment":"Permanent","department":"FinTech - Finance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718852731439,"descriptionPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","id":"60283bc5-9f60-400a-8289-bcbe332fbc09","lists":[{"text":"What You Will Do","content":"<li><b>Planning</b>: Work closely with the budget owner to prepare annual budget planning, re-forecast, rolling forecast on a periodic business cycle. Review budget activities completed by the budget owner with accurate baseline, information, and proper justification</li><li><b>Controlling</b>: Responsible for reviewing and approving each spending related to Opex and Capex according to the applicable Expense Management PolicyWork closely with the budget owner to ensure each spending request is based on business requirements, supported by budget availability, and budget transfer process (if required). Collaborate with the other stakeholders in building the right cost base e.g., Procurement, Budget owner, etc.</li><li><b>Monitoring</b>: Create and refine report in order to provide the right data and information to the CFO, FBP and Budget Owner to analyze the actual spends against the available budget on monthly basis with a pre-defined report including its associated drivers. Understand the variance including the explanation and/or justification from the Budget Owner whenever the spend exceeded the approved budget. Continue to work closely with the Budget Owner in supporting the identification of risks &amp; opportunities for cost-efficiency purposes. Highlight key financial issues and deliver the proposed solutions to the stakeholders, provide insightful financial analysis on a regular and ad-hoc basis such as but not limited to topline daily/weekly tracker, business unit performance review, and other financial ratios analysisIn certain circumstances, this candidate will work with Cost Management Head to support the entire products under GoTo Financial product or Function group.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's or Master's Degree in Accounting / Finance/ Business, or equivalent educational background</li><li>Minimum 5 years of working experience in Finance Business Partner / Cost Control areas</li><li>Able to build a financial model, proficiency in Microsoft Excel and Gsheet/Gdocs</li><li>Strong business, data-driven acumen, and ability to work with big database</li><li>Able to manage multiple stakeholders across various levels of seniority</li><li>Strong project management skills to manage complex projects; able to prioritize multiple internal and external stakeholders; and able to drive consensus</li><li>Strong team player; possesses team synergy skills with a high level of enthusiasm in collaborating with cross-teams</li><li>Able to work independently and high attention to detail with swift execution</li><li>Proficiency with Finance / Accounting tools (e.g. SAP and ERP) is a plus</li><li>Fluent in English (written and spoken)</li>"}],"text":"Financial Controller Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.</div><div><br></div><div>You will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.</div>","descriptionBodyPlain":"About the Role\n\nAs Cost Management Manager, you will take the wheel in driving the preparation of annual Budget Planning and Re-forecast, Spending Control, and Monitoring of business performance measurement, particularly for Operating Expenditure (Opex) and Capital Expenditure (Capex) in GoTo Financial.\n\nYou will work closely with the GoTo Financial Group’s Budget Owner even across Gojek and GoTo to understand business nature in each function and product, identify risk and opportunity, and continue to seek operating efficiency, in addition to Planning, Controlling, and Monitoring.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09","applyUrl":"https://jobs.lever.co/GoToGroup/60283bc5-9f60-400a-8289-bcbe332fbc09/apply"},{"additionalPlain":"About the team \n\nThe Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. \n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Financial Services Compliance team is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Otoritas Jasa Keuangan (OJK) as the regulator. As a Financial Services Compliance team, we are obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Financial Services Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgments, and give advice to many other functions within the GoTo ecosystem. </div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721025492852,"descriptionPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","id":"a9daeacc-5dda-4735-ad7b-db35eb7593a6","lists":[{"text":"What you will do","content":"<li>Support Compliance and Regulatory Affairs matters in GoTo Financial Services operations, which includes but is not limited to business/product reporting and approval process with the regulators, compliance advisory assistance to business unit, as well as technical regulatory assessment</li><li>Provide Compliance advisory assistance for Financial Services operations, in both consumer and merchant-facing operation</li><li>Create and maintain the latest update of Financial Services regulations databases and provide/disseminate assessments on such regulations to the internal units in GoTo Financial</li><li>Provide assistance and support to the Head of Compliance and Senior Manager of Financial Services Compliance in any external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders</li><li>Give continuous support on the creation, standardization, and implementation of Financial Services Compliance, policies, terms &amp; conditions, internal working procedures, and standard operational guidelines</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law and Accounting. Having a master’s degree would be an advantage.</li><li>Possessing certifications in Risk Management/ IT Audit will be an advantage.</li><li>At least 4 years of mixed experience in the area of payment policy/ regulatory compliance.</li><li>Intermediate level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks, proactively choose the best solutions, and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including builds credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"FinServ Compliance Officer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Compliance Officer is a strategic role within the GoTo Financial Services division. As a junior member of the team, she/he will be expected to support the GTF Head of Compliance and Senior Manager PiC to ensure the alignment of GoTo Financial Services business units to grow sustainably through regulatory adherence. She/he will work across functions in GoTo Financial and GoTo Group to provide compliance advisory assistance to all functions, support technical product compliance risk assessment, reporting, and submissions to the regulators with the primary objective of ensuring the implementation of Financial Services regulations, industry standards, and good corporate governance principles in the operations of the Company/Group. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6","applyUrl":"https://jobs.lever.co/GoToGroup/a9daeacc-5dda-4735-ad7b-db35eb7593a6/apply"},{"additionalPlain":"The Fleet Team is a newly established team in Gojek. The mission of the team is to create strategic partnerships to increase GoCar supply in a sustainable way, which in turn will enhance customer reliability, and create a bigger market for ride-hailing in Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Fleet Team is a newly established team in Gojek. The mission of the team is to create strategic partnerships to increase GoCar supply in a sustainable way, which in turn will enhance customer reliability, and create a bigger market for ride-hailing in Indonesia.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1722249916751,"descriptionPlain":"As Fleet Account Manager, you will be responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).\n","description":"<div><span style=\"font-size: 10pt\">As Fleet Account Manager, you will be&nbsp;responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).</span></div>","id":"c48698b4-3bff-4e56-b250-cadf67700c6d","lists":[{"text":"What you will do","content":"<li>Obtain in-depth and robust understanding of both Gocar &amp; fleet partners business needs / issues, at the same time act as a trusted advisor for them to sustain and grow their business</li><li>Create pipeline and bring in new fleet partners into Gocar ecosystem</li><li>Find ways to leverage Gojek’s existing structures (eg. driver engagement) to exert influence over driver’s SH/AR/CR/location</li><li>Develop end-to-end joint business plans, monitor fleet partner’s performance versus target, assess competitive benchmarking and anticipate potential business challenges</li><li>To take responsibility for all services that Gojek delivers to each account, become the single point of contact from Gojek for engagement, project delivery &amp; troubleshooting efforts</li><li>To playbook these efforts and scale your knowledge and best practices to operations team</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 6 years work experience in relevant sectors, e.g. account management, management consulting, PMO in reputable&nbsp; organizations</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in Bahasa Indonesia (must-have) and English (nice-to-have)</li><li>Strong business acumen (have a basic understanding of P&amp;L/profit &amp; loss)</li><li>Ability to deliver results and close win-win deals / agreements</li><li>Able to articulate knowledge and insights into document that can be leveraged across the orgarnization</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Fleet Account Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Fleet Account Manager, you will be&nbsp;responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).</span></div>","descriptionBodyPlain":"As Fleet Account Manager, you will be responsible to define processes to develop long-term relationships with all types of fleet partner, to lead your peers and engagement with fleet partners to provide best-fitted Gojek solution that will help them grow their business. The goal is to produce more vehicle supply for GoCar (in terms of SH and # of drivers/vehicles).\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d","applyUrl":"https://jobs.lever.co/GoToGroup/c48698b4-3bff-4e56-b250-cadf67700c6d/apply"},{"additionalPlain":"About the Team\n\nWorking with our team is an exciting and enriching experience, as we play a pivotal role in shaping the frontend ecosystem of the organization. As a cohesive unit, we focus on several key aspects, making our collaboration both productive and rewarding.\n\nOur team takes pride in developing and maintaining the central design system. This system ensures consistency and efficiency across all our web applications, resulting in a seamless and unified user experience. We are at the forefront of building and optimizing our web platform tooling. These tools enhance our productivity and code quality, allowing us to deliver exceptional frontend solutions efficiently. We actively contribute to internal product development. Our expertise in frontend engineering enables us to align with product visions and business objectives, ensuring the successful delivery of high-quality products that delight our users. By adhering to industry standards and conducting thorough code reviews, we ensure that our codebases are consistent, maintainable, and secure. This commitment to excellence translates into reliable and robust applications.\n\nWorking together, we foster an inclusive and supportive environment where every team member's ideas and perspectives are valued. Our dedication to mentorship and knowledge sharing ensures that we grow both as individuals and as a team. As a member of our team, you will have the opportunity to expand your skills, learn from experienced peers, and make a meaningful impact on the organization's frontend landscape. Collaboration, innovation, and a passion for frontend development define us. We welcome individuals who share our enthusiasm and dedication to join us on this journey of building exceptional web experiences and driving standardization across our organization.\n\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Working with our team is an exciting and enriching experience, as we play a pivotal role in shaping the frontend ecosystem of the organization. As a cohesive unit, we focus on several key aspects, making our collaboration both productive and rewarding.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team takes pride in developing and maintaining the central design system. This system ensures consistency and efficiency across all our web applications, resulting in a seamless and unified user experience. We are at the forefront of building and optimizing our web platform tooling. These tools enhance our productivity and code quality, allowing us to deliver exceptional frontend solutions efficiently. We actively contribute to internal product development. Our expertise in frontend engineering enables us to align with product visions and business objectives, ensuring the successful delivery of high-quality products that delight our users. By adhering to industry standards and conducting thorough code reviews, we ensure that our codebases are consistent, maintainable, and secure. This commitment to excellence translates into reliable and robust applications.</span></div><div><br></div><div><span style=\"font-size: 16px\">Working together, we foster an inclusive and supportive environment where every team member's ideas and perspectives are valued. Our dedication to mentorship and knowledge sharing ensures that we grow both as individuals and as a team. As a member of our team, you will have the opportunity to expand your skills, learn from experienced peers, and make a meaningful impact on the organization's frontend landscape. Collaboration, innovation, and a passion for frontend development define us. We welcome individuals who share our enthusiasm and dedication to join us on this journey of building exceptional web experiences and driving standardization across our organization.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1722247155831,"descriptionPlain":"About the Role\n\nAs a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups. \n\nIf working on deep & challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">If working on deep &amp; challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!</span></div><div><br></div>","id":"f7107250-7aa4-487c-8821-8948dfb0fbc3","lists":[{"text":"What You Will Do","content":"<li>Work with engineers and business stakeholders to understand the nature and background of the problems</li><li>Pair with fellow engineers to dissect the incoming problem statement and contribute to the solutioning</li><li>Craft reusable, reliable, accessible &amp; delightful UI components that work flawlessly across various web browsers &amp; devices</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Build and maintain various utilities focused on improving designer or developer productivity</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Ensure that the application and its components are robust by writing automated tests which covers all the critical flows in the application.</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript</li><li>Solid command over React JS with the flavor of TypeScript</li><li>Keen design and UX sense to analyze and understand the designs and wireframes</li><li>Good understanding of common web security threats and practices along with OWASP 10</li><li>Experience with <a href=\"http://node.js\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Frontend Engineer - Web Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">If working on deep &amp; challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer in the Web Platform team, you will be working closely with designers, backend engineers and other frontend engineers to craft UI components, build product features, enhance web platform tooling that will impact the whole frontend landscape of the organization. You will play an integral role in the execution of our web standardization plans by understanding the existing workflows, research, propose and build necessary tools and processes. What we do as part of this team will define how frontend engineering is carried out across teams and product groups. \n\nIf working on deep & challenging problems in the web frontend landscape excites you, we’ll love for you to come and join us!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3","applyUrl":"https://jobs.lever.co/GoToGroup/f7107250-7aa4-487c-8821-8948dfb0fbc3/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705377654170,"descriptionPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","id":"a3543985-6d2c-45cf-84f7-312ec7efed36","lists":[{"text":"What Will You Do","content":"<li>Write and deploy code that's clear, concise, performant, tested, and easy to understand by other teams and engineers</li><li>Participate in design reviews and own feature development from end to end</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices</li><li>Deep dive and debug production issues across services and levels of the stack when needed</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently</li>"},{"text":"What Will You Need","content":"<li>5+ years experience building consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Proficiency with one or more programming languages like Java, Go, and Kotlin.</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, asynchronous programming, fault tolerance and monitoring, performance, feature flags</li><li>Understanding how mobile/web applications interact with back-end and other systems. Experience in building frontend UIs is a bonus</li><li>Good understanding of SQL/NoSQL databases</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, GCP</li><li>Excellent verbal and written communication skills</li><div><br></div>"}],"text":"Full Stack Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.</div>","descriptionBodyPlain":"About The Role\n\nAt GoTo, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As our Senior Software Engineer, you'll craft high-quality, performant code, taking ownership of end-to-end feature development. As a key contributor, you will play a crucial part in shaping the future of our Consumer Lending products, ensuring they not only meet but exceed the evolving needs of millions of users. This is an exciting opportunity to make a lasting impact on the financial industry while advancing your career in a dynamic and innovative environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36","applyUrl":"https://jobs.lever.co/GoToGroup/a3543985-6d2c-45cf-84f7-312ec7efed36/apply"},{"additionalPlain":"About the Team :\nWe are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \nThis includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team :</b></div><div><span style=\"font-size: 10pt\">We are a team of developers, designers, and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><span style=\"font-size: 10pt\">This includes gathering any new data points and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><span style=\"font-size: 10pt\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718186798651,"descriptionPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","id":"6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","lists":[{"text":"What You Will Do","content":"<li>Build highly reliable frontend apps through appealing visual design with API integrations to support continuing increases in adoption of the products within Gojek</li><li>Work with engineers to understand the nature and background of the problems.</li><li>Work closely with all Data Platform teams to develop and rollout high quality products</li><li>Research &amp; prototype different approaches to find elegant solutions to complex web user interface challenges that sit right at the intersection of design, engineering &amp; user experience</li><li>Write concise, maintainable, efficient code that brings joy to present &amp; future maintainers</li><li>Author effective technical documentation, guides, RFCs using simple &amp; clear language</li><li>Contribute to improving team relatedness, and helps build a culture of camaraderie</li><li>Continuously refactor applications to ensure high-quality</li>"},{"text":"What You Will Need","content":"<li>At least 2+ years of experience in building interactive desktop and mobile web applications using HTML5, CSS3 and Javascript.</li><li>Solid command over React JS with the flavor of TypeScript.</li><li>Keen design and UX sense to analyze and understand the designs and wireframes.</li><li>Good understanding of common web security threats and practices along with OWASP 10.</li><li>Experience with <a href=\"http://node.js\" class=\"postings-link\">node.js</a>, package management with npm/yarn, transpilation with babel/TypeScript, bundling with rollup/webpack and equivalent tooling along with Express JS to be used as a BFF server.</li><li>Compassionate collaboration skills to work effectively in a diverse, cross functional team</li><li>Excellent written and verbal communication skills to help in collaboration and stakeholder management.</li><li>A “make and show” attitude with quick iteration skills</li>"}],"text":"Fullstack Engineer - Engineering Platforms","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span></div><div><span style=\"font-size: 10pt;\">You will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.</span></div><div><span style=\"font-size: 10pt;\">As a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep &amp; challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!</span></div>","descriptionBodyPlain":"About the Role :\n\nAs Gojek is undergoing exponential growth, our data has followed the same growth curve. Thus, as an integral member of the Data Platform team, you'll be at the epicenter of one of Southeast Asia's most coveted companies, and get to witness and solve the challenges that come with rapid scaling.     \nYou will be part of the Data Platform team. You’ll be responsible for helping develop and maintain the next-gen self-serve console portal. Most of Gojek internally relies on it, thus the responsibility increases to provide high-quality products.\nAs a Software Engineer in the Platform team, you will be working closely with designers, backend engineers, and other frontend engineers to craft UI components, build product features, and enhance web platform tooling that will impact the whole frontend landscape. If working on deep & challenging problems in the web frontend landscape excites you, we’d love for you to come and join us!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e","applyUrl":"https://jobs.lever.co/GoToGroup/6a1a9ce6-2c6a-494a-ba45-d597f8408c8e/apply"},{"additionalPlain":"About The Team\n\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</div><div>We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</div><div>Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718006842841,"descriptionPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","id":"7d1c915f-ac53-4a2c-887a-41bbbda48a26","lists":[{"text":"What You Will Do","content":"<li>Execute design tasks such as layout composition, image editing, typography, and color correction</li><li>Assist in the development of design concepts for various marketing collateral, including digital advertisements, print and digital materials, and more</li><li>Support the Art Director to provide visual assets for video and key visuals productions</li><li>Think creatively to generate visuals that connect with target audiences</li>"},{"text":"What You Will Need","content":"<li>A bachelor’s degree, with 3 years of experience in a related field</li><li>Proficiency in design software such as Adobe Creative Suite (Photoshop, Illustrator, and Premier), with a basic understanding of design principles and techniques</li><li>A portfolio showcasing examples of design work</li><li>Strong attention to detail and a passion for visual storytelling, with the ability to create compelling designs that resonate with the target audience</li><li>A can-do attitude with a determination to see tasks through to completion</li><li>Enthusiasm for design and a proactive attitude, with a desire to contribute ideas, and solve problems creatively</li>"}],"text":"Graphic Designer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.</div>","descriptionBodyPlain":"About The Role\n\nAs a Graphic Designer, you will be involved and working closely with Art Directors and Project Manager to develop creative assets with engaging visuals and will have the chance to gain hands-on experience and grow within a supportive and collaborative environment. This role might be interesting but challenging because you will be balancing multiple projects simultaneously, and adapt to different design styles.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26","applyUrl":"https://jobs.lever.co/GoToGroup/7d1c915f-ac53-4a2c-887a-41bbbda48a26/apply"},{"additionalPlain":"About The Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Growth Analyst role will be reporting directly to the Head of Consumer Acquisition & Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Growth Analyst role will be reporting directly to the Head of Consumer Acquisition &amp; Activation which focuses on Consumer Payment business function in GoTo Financial and located in Jakarta, Indonesia.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Consumer Experience","allLocations":["Jakarta"]},"createdAt":1721795385137,"descriptionPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","description":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","id":"5f86f9c4-80bc-437f-b09c-b61fd85c27eb","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Drive actionable insights recommendation such as making funnel conversion analysis, cohort analysis, long-term trends, user segmentation, etc.</li><li>Identify the business need and generate analysis&nbsp;</li><li>Create and manage dashboards and data pipelines to monitor metrics to measure business performance</li><li>Working closely with the Business team and other data team (Data Engineer, Business Intelligence) to implement data solution</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 2 years of working experience in data analytics field</li><li>Proficiency in data analysis tools, SQL. Strong analytical skills to interpret complex data sets and extract actionable insights.</li><li>High proficient in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficient in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Data Management: Familiarity with data collection, storage, and management best practices.&nbsp;</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li>"}],"text":"Growth Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About The Role</div><div><br></div><div>We are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition &amp; Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a data-driven and strategic Growth Analyst to join our Consumer Acquisition & Activation team at a leading financial technology company in Jakarta. The Growth Analyst will be responsible for analyzing data, identifying growth opportunities, and optimizing strategies to drive customer acquisition and activation. This role requires strong analytical skills, a deep understanding of marketing and growth strategies, and a passion for the fintech industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb","applyUrl":"https://jobs.lever.co/GoToGroup/5f86f9c4-80bc-437f-b09c-b61fd85c27eb/apply"},{"additionalPlain":"About the Team\n\nThe Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Consumer Lending team at GTF is passionate about empowering our users with the tools to be financially responsible. The Growth role is at the center of the business, where we help direct the product toward the right solutions by tackling the right problems through exploratory data analyses and rapid experimentation. Imagine a blend of data analysis, marketing, statistical testing, and product management; that sweet spot is where we're at. We're a team that's always willing to get our hands dirty, meaning we're responsible for analyzing, designing, and also executing because we believe that high impact comes from high accountability. If you're a data whiz who enjoys the collaborative nature of solving business problems, then you might be our person.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720079397618,"descriptionPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","id":"9bc8bd8a-cadc-4942-81c4-193773a294df","lists":[{"text":"What You Will Do","content":"<li>Design and own growth strategy of GoPay Later product; make data-driven business decisions on a regular&nbsp;</li><li>growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps, and actual customer insights</li><li>Test and validate solutions through a proper experimentation process</li><li>Liaise with other analytical chapters within the Financial Services Platform as well as across Gojek such as Data Science, Data Engineering, Data Governance, Risk Analytics, etc, to ensure that initiatives are aligned and data integrity standards are adhered to.</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 2 years of working experience in an analytical role (data analyst / BI/data science/statistician, etc)</li><li>Strong SQL skills with expertise in either Excel/Python/R</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps</li><li>Strong project management skills to manage projects; able to work together with relevant units, also can manage and prioritize multiple internal stakeholders</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team</li>"}],"text":"Growth Analyst - GoPay Later","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>As a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance &amp; Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.</div>","descriptionBodyPlain":"About the Role \n\nAs a Growth Analyst on the Consumer Lending team, you will be responsible for growing our Consumer Lending business within Gojek and GoPay platforms. The scope includes making data-driven business decisions, running various experiments within the platforms, as well as working together with the Product team to develop new features as part of driving financial product growth. You will also be working closely with the Credit Risk team to enable and drive acquisition, activation, retention, and cross-selling, Finance & Stratplan team to manage and forecast the business budget, and Legal and Compliance team to check and balance of our growth initiatives. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df","applyUrl":"https://jobs.lever.co/GoToGroup/9bc8bd8a-cadc-4942-81c4-193773a294df/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713765081862,"descriptionPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","description":"<div><span style=\"font-size: 10.5pt\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","id":"761415aa-89b7-4ffb-a19b-2b91ac4243b4","lists":[{"text":"What You Will Do","content":"<li>Lead the strategy and growth function for GoModal. You will be collaborating with the Marketing &amp; Product teams on a daily basis.</li><li>Maintain rigor in analytical excellence in terms of data analytics, A/B test design, and appropriate statistical tests across the product funnel from acquisition, adoption, retention to monetization.</li><li>Discover growth opportunities in the product from funnel conversion rates and user experience by exploring transaction data, customer activity within apps and actual customer insights.</li><li>Analyze our complex and ever-growing data, present insights, and propose strategic options to management to drive business decisions.</li><li>Test and validate solutions through proper experimentation process.</li><li>Importantly, using data to identify growth opportunities and problem solve so as to achieve business goals with metrics such as conversion rates of WL to submit KYC, adoption rate &amp; GTV (disbursement)</li>"},{"text":"What You Will Need","content":"<li>BS in Statistics, Math, Computer Science, Engineering, Economics, Business, or equivalent experience</li><li>At least 4 years of working experience in a growth or product role (growth marketing, data analyst, BI, strategy, etc).</li><li>Strong project management skill to manage complex projects; also can manage and prioritize multiple internal and external stakeholders.</li><li>Strong business acumen and analytical thinking. Comfortable to translate high-level business requirements into structured analytical steps.</li><li>Experienced planning, designing, and executing experiments. Also comfortable working with frequentist statistics to analyze experiment results.</li><li>Strong data visualization and data storytelling skills.</li><li>Hustle is essential, moving quickly and executing to allow for continual iteration is a core competency of our team.</li><li>Preferred but not required: Strong SQL skills with expertise in either Excel/Python/R&nbsp;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Growth Lead (Merchant Lending)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.</span></div>","descriptionBodyPlain":"As a GTM Lead for the Merchant Lending team, you will be responsible to drive product strategy and business growth for merchant credit lines offered to GoBiz sellers. This role requires a person who is data driven, a growth marketer will create tests and experiments to positively influence customer acquisition, customer conversion, customer retention and customer lifetime value. You will utilize our voluminous data to improve acquisition, activation, retention, and loyalty for our product. You will be driving the growth strategy and analytics projects of the Growth team for the product, ultimately enabling the Merchant Lending team to make data-driven decisions. You will have ample opportunity to flex your analytics and project management skills, getting us even closer to the financial inclusion of all Indonesians. You will be based in the Jakarta office.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4","applyUrl":"https://jobs.lever.co/GoToGroup/761415aa-89b7-4ffb-a19b-2b91ac4243b4/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714985249008,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","id":"2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","lists":[{"text":"What You Will Do","content":"<li>Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Introduce beneficial business changes through well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve the business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li><li>Optimize and automate solutions by leveraging Data Sciences and Product resourcesProactively improve the operation process in the team and act on how to drive a faster, more effective, and efficient execution process through third-party tools or in-house service</li>"},{"text":"What You Will Need ","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience&nbsp;</li><li>Data analytics capability, have a good knowledge of SQL and experimentation processes; High Proficiency in Python and R is a plus</li><li>Strong business acumen and project management skills with successful experience in collaborating with cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Planning & Operation - GoFood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e","applyUrl":"https://jobs.lever.co/GoToGroup/2ae422f8-eced-4e9b-9ce5-5c7ec784fc0e/apply"},{"additionalPlain":"About the Team \n\nMeet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!\n\n\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We serve more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager and data Science to the Operation team. This team is the melting pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solutions, this is the right place for you!</div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717479647909,"descriptionPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","id":"1fad1d82-dc7b-4d5a-b0d0-eb4678350242","lists":[{"text":"What You Will Do","content":"<li>Lead and Discover growth opportunities from the interaction of GoFood and its merchants through all of the metrics by running data analysis from Gojek’s vast data resources including business data, transaction data, customer activity within apps, and actual customer insights</li><li>Work closely with the Product, Marketing, Sales, Research, and Intelligence teams to understand merchant pain points and define the solution as well as Data, Ads, and Operation teams in the development and implementation of initiatives and strategies</li><li>Prepare reports of key merchant metrics analysis as a basis of rationale and recommendations to upper management, including CxOs of Gojek and GoTo Group</li><li>Conduct competitive benchmarking and analysis with local and international counterparts</li><li>Introduce beneficial business changes through a well-written strategy document; validate the hypotheses through A/B test or other robust experimentation method</li><li>Operate the product solution and define the program to achieve business objectives by combining multiple initiatives (e.g. promotion program, incentive product, and discovery product )</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Economics, Statistics, or equivalent experience</li><li>Minimum 3 years of working experience</li><li>Strong critical thinking, coordination, and stakeholder management skills to drive analysis and cross-collaboration independently</li><li>Data analytics capability have a good knowledge of SQL and experimentation process; High Proficiency in Python and R is a plus</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also being a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Experience in Growth, Product Management, and Data team is a plus</li>"}],"text":"Growth Strategy Manager - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?</div><div><br></div>","descriptionBodyPlain":"About the Role \n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with a focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that?\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242","applyUrl":"https://jobs.lever.co/GoToGroup/1fad1d82-dc7b-4d5a-b0d0-eb4678350242/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719458638459,"descriptionPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","description":"<div><span style=\"font-size: 10pt\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","id":"b68a9eb5-f615-441a-b04c-2d2c6a9d4703","lists":[{"text":"What You Will Do","content":"<li>Perform development and review of Business Continuity Management Framework and its supporting policies;</li><li>Strategize, coordinate, and provide challenge and advisory in the implementation of Business Continuity Programs such as BCP, BCP testing, Crisis Management exercise, and ways of integrating Business Continuity concept and awareness in the operational of business and support functions;</li><li>Respond to audit and regulatory requirements on BCM;</li><li>Design and deliver BCM communications and clinic sessions;</li><li>Provide Business Continuity update report to Management</li><li>Facilitate and support the execution of the plans at the time of a crisis event.</li>"},{"text":"What You Will Need","content":"<li>Minimum bachelor’s degree in relevant discipline from a reputable university</li><li>Minimum 8 years of Business Continuity Management experience in prominent consulting firms and/or multinational companies</li><li>Growth mindset, analytical, assertive and good interpersonal skill</li><li>Relevant BCM certifications&nbsp;</li><li>Good competency in English, verbal and written.</li>"}],"text":"Head of Business Continuity Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.</span></div>","descriptionBodyPlain":"Business Continuity Management (BCM) Head oversees the development, review, and implementation of Business Continuity Management Framework, including their adherence to regulatory requirements and best practice standards. This position’s scope of work covers the whole GoTo ecosystem, which consists of e-commerce, on-demand-service, logistics, and financial technology. Therefore successful candidate will obtain exposure to implementing business continuity in the Group’s fast and dynamic business operations. The goal of BCM is to drive and continously enhance the Group’s resilience and continuity. You will be based in Pasaraya office - Jakarta, with full working from office arrangement.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703","applyUrl":"https://jobs.lever.co/GoToGroup/b68a9eb5-f615-441a-b04c-2d2c6a9d4703/apply"},{"additionalPlain":"Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717651947726,"descriptionPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><span style=\"font-size: 16px\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"c838dc08-24e8-417c-9d70-a617bc58e200","lists":[{"text":"Responsibilities","content":"<li>Gojek is looking for an experienced technologist with a passion &amp; understanding of technology to lead its transportation product. Transport is one of the flagship products in GOJEK superapp. It is launched in Indonesia, Singapore and Vietnam.</li><div><br></div><li>As Head of Engineering of Transport, you will partner with GOJEK VP, Senior VP of technology, Transport Head of Business, Group Product Manager and other business stakeholders in the company to formulate a business strategy for Transport. You will work closely with PMs and Tech Leads in Transport to realize this strategy to make GOJEK a dominant player in markets.</li><div><br></div><li>Strategic thinking and strong business acumen along with deep technical expertise are essential in this role. We expect you to be well-versed in current technological trends and familiar with a variety of business concepts. If you are also an excellent communicator and public speaker, we’d like to meet you.</li><div><br></div><div>What you will do</div><div><br></div><li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Setup growth paths for the team and engage them in processes and practices that shall help scale engineering</li><li>Collaborate with cross functional teams and stakeholders (Business, Product, Data, UX, Platform, Devops etc.) to unlock the next phase of business growth.</li><li>Provide technology leadership to the team and foster engineering excellence.</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"Experience and Skills","content":"<li>Should have at least 9 years of hands-on experience in designing, developing, testing and deploying applications at scale.</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus.</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation.</li><li>Experience as people manager and passionate towards building and growing a high functioning team.&nbsp;</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions.</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities.</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Head of Engineering - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">We are looking for a Head of Engineering for the Transport team. </span></div><div><span style=\"font-size: 16px;\">As part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. </span></div><div><span style=\"font-size: 16px;\">You will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. </span></div><div><span style=\"font-size: 16px;\">You should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. </span></div><div><span style=\"font-size: 16px;\">Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"We are looking for a Head of Engineering for the Transport team. \nAs part of this role you will be required to keep and raise the bar of engineering excellence, setting up growth paths and structure for the team, establishing best practices for the team to function efficiently. \nYou will be responsible for managing the overall engineering charter for the Transport business vertical. You would be collaborating with stakeholders across several functions including engineering, product and business functions to define and enable the next phase of evolution of the product. \nYou should be someone who is passionate about technology, willing to unlearn and learn, has hands-on experience, and forthcoming to mentor and guide the team towards technical know-hows and help in ideating with the team to build simple yet elegant solutions for different business needs. \nYour ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200","applyUrl":"https://jobs.lever.co/GoToGroup/c838dc08-24e8-417c-9d70-a617bc58e200/apply"},{"additionalPlain":"About The Team\nYou will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">You will join a team with multi-location offices and multi-culture environment, the team members here are full of passion and open-minded.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718871657577,"descriptionPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","id":"6dc20c4e-4d40-4f57-a138-4776013e454e","lists":[{"text":"What You Will Do","content":"<li>Oversee CS, Telesales, KYC, collection and FI team and Ops projects for our BNPL and cashloan product.&nbsp;</li><li>Develop &amp; Optimize Processes - Scale new and existing processes to allow the business to efficiently operate in Indonesia</li><li>Analytics - Analysis and tracking of onboarding, merchant experience and technical issues, risk management etc</li><li>Strategy - Choose which projects to prioritize, and set a timeline to reach goals quickly</li><li>Tool Improvements - Proactively search for new tools or ways which could improve a seamless support and setup experience, for both, merchant and buyer</li><li>Be fast, resourceful, and take initiative - Take ownership of regional commerce operations and do everything you can to support and enhance the quality of our services</li>"},{"text":"What This Role Needs","content":"<li>Min. 7 years experience in tech startup/fintech industry</li><li>Experience in operations strategy, sales strategy and product management is a big plus</li><li>Proven success in dynamic and complex environments, with a proven ability to rally teams and influence at all levels</li><li>Deep analytical skills, with high capacity to think strategically about complex issues, evaluate alternatives, and make compelling recommendations based on proven business case analysis</li><li>Outstanding communication skills, both verbal and written</li><li>Ability to lead complex and strategic initiatives and communicate effectively with technical teams</li><li>Ability to collaborate with various departments by utilizing superior relationship-building skills, interpersonal skills, and influence</li>"}],"text":"Head of Operation - Consumer Lending - #10162","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Oversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,&nbsp; growth team and also cross-functionally you will work with other business lines to ensure the best customer experience.&nbsp;</span></div>","descriptionBodyPlain":"About The Role\nOversees the entire operation team including but not limited to customer service, telesales, collection, KYC, FI and operation excellence team. You will work closely with risk team,  growth team and also cross-functionally you will work with other business lines to ensure the best customer experience. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e","applyUrl":"https://jobs.lever.co/GoToGroup/6dc20c4e-4d40-4f57-a138-4776013e454e/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705905810213,"descriptionPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","description":"<div><b><span style=\"font-size: 18px\">About The Role</span></b></div><div><span style=\"font-size: 16px\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","id":"70493d8a-7d7f-4660-b1ed-c792d0d765be","lists":[{"text":"What You Will Do","content":"<li>Developing and implementing commercial strategies in line with company goals and objectives, with the aim to accelerate growth</li><li>Managing senior members of the Sales (enterprise merchants, SMB and very small merchants), by extension, their teams</li><li>Managing existing client relationships - understanding their requirements, ensuring their needs are met</li><li>Designing and implementing new sales and merchant acquisition strategies</li><li>Collaborating with and coordinating diverse teams (e.g. marketing, sales, customer service)</li><li>Negotiating ongoing contracts with merchants,; managing and reviewing contracts and making recommendations regarding commerciality</li><li>Monitoring performance of commercial activities using key metrics and reporting to senior management</li><li>Assisting with the setting, managing, and monitoring financial targets and budget development</li><li>Establishing and maintaining long-term, profitable partnerships with key stakeholders</li>"},{"text":"What This Role Needs","content":"<li>At least 15 years of working experience in the related field</li><li>Must have experience leading at least two of the three merchant segments (Ent/key accounts, SMB, Unmanaged/long tail)</li><li>Experienced in managing a huge team size</li><li>Good to have -&nbsp; have managed P&amp;L&nbsp;</li><li>Strong Problem Solving capabilities</li><li>Agile and willing to adapt to rapidly changing situations/environments</li><li>Ability to manage multiple complex and matrixed sales engagements whilst always positioning the products at the center of the engagement</li><li>Demonstrated ability to build and maintain strong relationships with merchants</li><li>High energy and engagement ethos, self starter , out of the box thinker, able to stay motivated</li><li>An ability to quickly grasp key experiences and device spec and formulate a sales technique to overcome any objections</li><li>Excellent communication skills - presentation, negotiation, and closingExcellent in contract and commercial negotiation process</li><li>Experience in payment industry is a plus</li>"}],"text":"Head of Sales - Midtrans - #9618","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 18px;\">About The Role</span></b></div><div><span style=\"font-size: 16px;\">The Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.</span></div><div><br></div><div><span style=\"font-size: 16px;\">This position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.</span></div>","descriptionBodyPlain":"About The Role\nThe Head of Sales will work closely with the Head of Online Merchants to define the commercial vision and strategy, lead execution to deliver sales, increase margins and market share in online payment acceptance in Indonesia by acquiring new merchants. The Head of Sales will also be responsible for business development, commercial effectiveness, business analytics, and market intelligence in related to improve merchant retention and trust.\n\nThis position reports directly to the Head of Online Merchants and one of the key positions in the Merchant Services senior leadership.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be","applyUrl":"https://jobs.lever.co/GoToGroup/70493d8a-7d7f-4660-b1ed-c792d0d765be/apply"},{"additionalPlain":"About The Team\nAs Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.\n\nOne of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing & executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.\n\nWe are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 14px\">As Gado-Gado is to the people of Indonesia, the Sales Strategy team is to Gojek: providing the nourishment to sustain our business from the inside out. The gist of our role is to be the main liaison between our merchant-partners and our product business teams, and work to create the overall go-to market plan and strategy for all merchant segments within Gojek. It’s our job to ensure that our solutions effectively meet the needs of our merchant-partners, reducing their daily frictions and ensuring they have a seamless, enjoyable experience using our services.</span></div><div><br></div><div><span style=\"font-size: 14px\">One of our recent proud moments is our success in growing merchant-partners’ business and ultimately GoFood business as well. It took a village to achieve this by closely coordinating with other relevant teams (i.e., demand generation, marketing, ads/ promotech etc) on designing &amp; executing the best construct for each merchant segment. It was an exciting journey with clear impact for our merchant-partners.</span></div><div><br></div><div><span style=\"font-size: 14px\">We are a highly flexible team that holds each individual accountable for their own delivery of KRs and initiatives. As a team, we’re concerned not only with the growth of the company, but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of good food and hilarious memes (a peek at our WhatsApp group would probably just show a whole collection of memes we've sent each other😜).</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Strategy","allLocations":["Jakarta"]},"createdAt":1708937527995,"descriptionPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","id":"7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","lists":[{"text":"What You Will Do","content":"<li>Design the overall end-to-end sales strategy which includes go-to-market (GTM) strategy and implied sales motions / incentives system</li><li>Define OKR &amp; building blocks for the entirety of nationwide sales team (Enterprise &amp; Small Medium Business teams) to ensure that company objectives are met - working closely with the product teams (including but not limited to GoFood, GoMart, GoCorp and GoPay)</li><li>Set sales targets in areas like product mix, sales volume, and market shares</li><li>Track OKR &amp; performance of the overall greater sales team (Enterprise, SMB Managed &amp; SMB Unmanaged teams) across all products</li><li>Oversee the execution of sales motions / building blocks: periodic review with working and/or leadership team, provide guidance to the overall sales strategy &amp; other relevant stakeholders</li><li>Establish a regular &amp; methodical planning rhythm to ensure that both sales team structure &amp; compensation plan are aligned to support reaching company targets. This would include merchant segmentation, sales structure review, sales earning optimization exercises, account mapping, territory planning; working together with the Head of Enterprise Sales and Head of SMB Sales</li><li>Become the bridge between Sales HQ &amp; on-the-ground merchant-facing teams to ensure seamless &amp; effective execution</li>"},{"text":"What This Role Needs","content":"<li>At least 10 years of relevant work experience in strategy, preferably within mid-to-senior management level from multinational company</li><li>Have strong analytical thinking and problem solving skills using various tools and methods</li><li>Comfortable working under pressure in a fast-paced and ambiguous environment</li><li>Ability to prioritize &amp; multitask across different initiatives (balancing breadth vs in-depth)</li><li>Strong business sense and ability to articulate complex analysis results to a wide range of audiences and translate the results to actionable business insights</li><li>Have great presentation skills - esp. the ability to present to senior management &amp; leadership</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>Fluent in Bahasa Indonesia &amp; English</li>"}],"text":"Head of Sales Strategy - #10056","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">If you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.</span></div>","descriptionBodyPlain":"About The Role\nIf you’re looking for a place with dynamic, high analytical thinking and have passion to grow the industry by leveraging the digital platform/technology, look no further. As the Head of Sales Strategy, you will be the brain and key motor to the motion of the greater sales team. You will be responsible to lead the team that supports the merchant-facing team by developing sales OKR, go-to-market strategy, as well as sales motions and building blocks to support merchant-facing teams to reach their targets. You will work very closely with the product business teams to ensure that the respective product and company objectives are met.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6","applyUrl":"https://jobs.lever.co/GoToGroup/7f2a39e7-fa94-44df-ba38-45fcc9ee8fa6/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Enterprise Risk Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721030934590,"descriptionPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","description":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","id":"9c0a73a5-09ce-4b06-8527-9415ef3d393c","lists":[{"text":"What You Will Do","content":"<li>Lead a team of IT Auditors in planning, preparation, coordination, and execution of audits to evaluate the adequacy and effectiveness of technology infrastructure, application, and process controls.</li><li>Provide clear, concise, and organized documentation of the audit processes and findings.</li><li>Identify and evaluate complex technology and business risks, implications, and related opportunities for improvements of internal controls.</li><li>Manage audit projects effectively – resource allocation, deliver on commitment, time management and quality reviews.</li><li>Serve as the Audit Committee Secretariat responsible for coordination of materials across the governance teams for periodic AC meetings.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Must have a minimum of 8-10 years of experience in technology audits, with at least 5 years in public accounting / advisory firms.&nbsp;&nbsp;</li><li>Must have strong practical experience in testing of GITC, application controls, ISO 27K, cybersecurity risk assessment, and ERP’s.&nbsp;</li><li>Must possess CISA certification at a minimum - additional certification in cyber, risk and technology governance preferred.&nbsp;</li><li>Knowledge and experience with OJK and Bank Indonesia (BI) technology audit requirements preferred.&nbsp;&nbsp;</li><li>Experienced with coaching and developing junior team members, strong confidence to interact with various stakeholders, excellent project management and organizational capabilities, ability to complete tasks and audit projects within tight deadlines.</li><li>Strong communication in English (verbally and in writing) and PowerPoint preparation skills.&nbsp;</li><li>Highly self-motivated, inquisitive (with a keen interest in learning new processes and technologies) and strive to continuously develop technically and professionally.</li>"}],"text":"Internal Audit Senior Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.&nbsp; As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.&nbsp; &nbsp; You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.&nbsp; &nbsp;</div>","descriptionBodyPlain":"In GoTo, the growth of our business is continuously challenged by the fast pace of technology development and regulatory changes.  As the Senior Manager, you will lead the IT audit team in planning and delivering on internal IT audit commitment.    You will grow both technically and professionally through interaction with one of the most dynamic and driven management teams, exposure to the latest technologies and observe first-hand on tech-enabled business strategy.   \n","hostedUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c","applyUrl":"https://jobs.lever.co/GoToGroup/9c0a73a5-09ce-4b06-8527-9415ef3d393c/apply"},{"additionalPlain":"Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Working within corporate affairs at GoTo involves being part of a close knit team with a vibrant and collaborative culture. You will spend much of your time engaging with colleagues in Jakarta, while also acting as a leader within the Singapore business. There is a huge amount to learn and no two days are the same, so those who excel here are passionate about managing diverse projects and disciplines, driven by a meticulous approach to execution. It's a culture that values versatility and adaptability, providing a stimulating environment for professional growth and achievement.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - Corporate Affairs","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1720685009263,"descriptionPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","description":"<div><span style=\"font-size: 11pt\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","id":"fc5f2c90-038e-4c53-9971-2ae72f680c03","lists":[{"text":"What you will do","content":"<li>Gojek Singapore communications:</li><div>Serve as the overall PR point of contact and develop communications strategies for the Singapore market, collaborating with the Gojek Singapore leadership team.</div><div>Develop and execute PR plans for Singapore-related announcements, handling all external-facing communications and materials.</div><div>Engage with Singapore media, manage media queries, and manage crisis and issues across media <a href=\"http://channels.Proactively\" class=\"postings-link\">ch</a>annels</div><div>Proactively seek thought leadership opportunities and lead OKR reporting for PR-related <a href=\"http://metrics.GoTo\" class=\"postings-link\">me</a>trics</div><div><br></div><li>GoTo Group communications support:</li><div>Support Group-level announcements and the development of associated English language communication materials</div><div>Maintain relationships with key international media contacts and handle media queries</div><div>Support issues management teams.</div><div>Develop thought leadership content, manage media opportunities and awards, and oversee a number of owned channels.</div><div><br></div>"},{"text":"What you will need","content":"<li>Excellent writing skills - proficiency with Chinese language media in Singapore is a bonus</li><li>Proven ability to build and maintain relationships with media contacts</li><li>Experience in pitching stories and managing media inquiries.</li><li>A cool head in a crisis</li><li>Meticulous approach to reviewing materials and ensuring accuracy</li><li>Ability to manage multiple projects without compromising quality.</li><li>Flexibility to manage unexpected challenges and opportunities</li><li>Enthusiasm for travel (regular travel to indonesia will be required) </li><div><br></div>"}],"text":"International & Singapore Communications Manager","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 11pt;\">This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt;\">This is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. </span></div><div><br></div>","descriptionBodyPlain":"This role is divided into two main components, the first involves leading all communication efforts for Gojek Singapore including strategy, corporate communications, and crisis and issues management. You will become embedded within the Gojek Singapore leadership team and will advise the business on its corporate reputation among local stakeholders. The second component involves supporting GoTo Group activities across financial and corporate communications as well as thought leadership. \n\nThis is a varied role that requires agility, determination and a flexible approach. One day you will be dealing with an unexpected issue arising out of our Singapore business, the next you will be supporting interviews and events for one of our Group board members. Enthusiasm for media, great writing skills and a strategic mindset are essential. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03","applyUrl":"https://jobs.lever.co/GoToGroup/fc5f2c90-038e-4c53-9971-2ae72f680c03/apply"},{"additionalPlain":"About the Team\n\nThe IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The IT Finance Systems team is an integral part of the GoTo CIO Office. This dedicated team is responsible for defining, maintaining, and ensuring standards for IT finance systems and data across the organization. By setting robust standards and protocols, the team ensures that all IT finance initiatives are aligned with the company's strategic objectives and comply with industry best practices.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721378203517,"descriptionPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","id":"4cb00240-117e-4ace-a959-fc567e447d5f","lists":[{"text":"What You Will Do","content":"<li>Manage multiple complex IT Finance initiatives</li><li>Ensure initiative deliveries are on time and adhere to IT Project Life-Cycle standards</li><li>Ensure information is delivered to the business through the correct channels, ensuring compliance with all controls and security requirements</li><li>Manage multiple internal stakeholders across countries and business units</li><li>Provide regular status updates to GoTo leaders and stakeholders</li>"},{"text":"What You Will Need","content":"<li>8+ years of work experience in IT project/program management in Finance Domain</li><li>Strong track record of leading successful IT projects/programs from start to finish&nbsp;</li><li>Ability to multi-task and effectively manage several projects in parallel</li><li>Ability to influence large, cross-functional teams</li><li>Strong interpersonal, facilitation, and leadership skills</li><li>Experience in managing Corporate Finance, Enterprise Data, and Enterprise business processes is highly desirable</li><li>Drive adherence to SDLC processes, drive to implement new processes and procedures applying industry knowledge and experience to cut costs, gain efficiencies, minimize risks, and reduce time to deploy, with attention towards automation and continuous improvement; make recommendations for process improvements; track and document all process improvements;&nbsp;</li><li>Good communication skills in English both oral and written</li>"}],"text":"IT Finance Project Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.</div>","descriptionBodyPlain":"About the Role\n\nAs an IT Project Manager at GoTo HoldCo, you will lead and manage organization-wide IT Finance systems and data-related initiatives from both technical and functional perspectives. This role requires a strategic thinker with excellent leadership skills to drive the successful delivery of complex projects. You will collaborate with cross-functional teams to ensure that projects align with business goals, comply with standards, and meet stringent deadlines.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f","applyUrl":"https://jobs.lever.co/GoToGroup/4cb00240-117e-4ace-a959-fc567e447d5f/apply"},{"additionalPlain":"About the Team\n\nJoining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Joining GoTo Financial (GTF) means becoming an integral part of a collaborative and dynamic team culture that values transparency, innovation, and teamwork. As a member of the GTF IT Governance, Risk, and Compliance (IT GRC) team, you'll find yourself immersed in an environment where your contributions are not only recognized but celebrated. You'll work alongside dedicated professionals within the GTF Compliance team, sharing insights, expertise, and best practices to ensure that our IT operations meet regulatory standards and industry requirements. Reporting directly to one of GTF's Head of IT GRC, you'll have the opportunity to learn from seasoned leaders in the field while also contributing your own unique perspective. Together, we'll continue to push the boundaries of innovation and set new standards for IT governance, risk management, and compliance in the financial industry.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713930486899,"descriptionPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","description":"<div><b style=\"font-size: 16px\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","id":"36caef5f-7a1c-4326-80b4-8c146060ac70","lists":[{"text":"What You Will Do","content":"<li>Develop and maintaining IT policies, standards and procedures according to applicable internal and external requirements, including the applicable regulations in Indonesia an other countries where GTF operate;</li><li>Develop and maintain compliance, governance and risk-related IT and business process flow;</li><li>Coordinating with compliance team to ensure that every initiative, development and collaboration are comply with the standards and regulations (internal and external);</li><li>Conduct routine evaluation of policies and procedures implementation and ensure best practice risk mitigation and assessment functions are maintained to comply with the company's strategy;</li><li>Coordinate with related IT work units to follow up on data requests and internal audit findings, external audits and regulators;</li><li>Develop the process and conduct the activities to safekeep or archive of every IT development document in a regular basis;</li><li>Implementing a good governance organization using the ISO27001, ISO 27701, PCI DSS framework and other relevant Technology &amp; Security best practices;</li><li>Develop and implement the RBAC and least privilege of access management in the GTF technology stack</li><li>Act as a Subject Matter Expert to the stakeholders and provide relevant &amp; applicable consultation for addressing the IT GRC requirement in lending product &amp; services.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years experiences as Information Security, IT Governance, Risk and Compliance (IT GRC) or IT Auditors;</li><li>Demonstrate excellent communication and writing skills and proficient with English written and spoken</li><li>Experienced in developing and maintaining IT and/or information security policies and procedures;</li><li>Excellent knowledge in developing risk management and IT framework, BIA, BCP and BCM Framework</li><li>Experienced in report document development and delivery;</li><li>Experienced in dealing with regulatory audit to represent the organization IT GRC operations;</li><li>Having good knowledge with local and regional payment &amp;&nbsp; lending regulatory requirements and how they impact IT policies (having experience is preferred);</li><li>Having excellent experience with ISO 27001, ITIL. COBIT, and PCI-DSS standards;</li><li>One or more of the following or equivalent certifications preferred: CISA, CRISC, ITIL, COBIT is preferred</li>"}],"text":"IT GRC Senior Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About The Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Join our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. </span></div>","descriptionBodyPlain":"About The Role\n\nJoin our team at GoTo Financial (GTF) as an IT Governance, Risk, and Compliance (GRC) Analyst where you'll play a crucial role in ensuring the secure and efficient operation of our IT infrastructure within the financial sector. Dive into the dynamic world of financial products and services, including payment and lending services. You'll gain firsthand experience in understanding the unique IT challenges and compliance requirements within the financial sector. As an IT GRC Analyst at GTF, you'll be at the forefront of safeguarding our IT environment, ensuring regulatory compliance, and upholding the trust of our customers. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70","applyUrl":"https://jobs.lever.co/GoToGroup/36caef5f-7a1c-4326-80b4-8c146060ac70/apply"},{"additionalPlain":"About The Team\n\nGoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.\n\nOur achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.\n\nAs a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design & Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>GoPay is a leading payment and financial services provider that aims to improve lives and promote financial inclusion by helping millions of Indonesians access digital banking, investment and insurance services.</div><div><br></div><div>Our achievements, including over 30 million downloads, the “Best Digital Wallet” award from The Asian Banker 2022, and being named Best App of 2023 by Google Play, are all possible because of our dedicated and hardworking team. When you join us, you’ll play a pivotal role in shaping the future, driving innovation, and making a significant impact on our rapidly expanding user base.</div><div><br></div><div>As a UX Writer team in GoPay, we’re a close-knit team where we foster a culture of collaboration and mutual support. We prioritize maintaining a healthy work-life balance and are dedicated to nurturing personal growth through mentorship and professional development opportunities. You will be part of the GoPay Design &amp; Research team consisting of 30+ passionate, welcoming, vibrant, and talented practitioners from Indonesia and India who happen to bond over dinners, coffee, and even workout sessions. Join us and experience a team where your voice matters, contributing to innovative solutions and creating impactful user experiences together.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720592684329,"descriptionPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","description":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","id":"da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of your Writer lead, and follow the predefined process that has been set by the team</li><li>Understand the product briefs and present ideas/solutions to the team under the supervision of your writer lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Proactively attend design reviews to gather feedback and provide critiques if needed</li><li>Proactively seek knowledge about UX</li><li>Participate in the end-to-end design process with peer researchers, designers, business, product and engineering teams. You will also get to engage with marketing and customer care unit to ensure the content is cohesive</li><li>Own your assigned streams and organize assigned tasks; which includes communicating updates and progress via the provided forums and channels. Be flexible to collaborate with other streams when needed</li>"},{"text":"What You Will Need","content":"<li>At least 1 year of experience in product writing for digital products or services</li><li>Strong understanding of writing fundamentals, critical/creative/structured thinking skills, grammar in both English &amp; Indonesian, and a familiarity of product design/ design thinking frameworks in order to further develop your writing output</li><li>Excellent communication and grammar skills in both English and Indonesian, both verbal and written, to effectively collaborate with stakeholders of varying seniority and backgrounds</li><li>A user-centric mindset in order to see things from their perspective, understand their concerns and feedback, and incorporate these insights into the work you produce</li><li>A drive to always find the root cause of an issue and validate your design - either through quantitative or qualitative research</li><li>A structured portfolio of written work that shows your ability and problem solving skills, a bonus if it demonstrates business impact and results</li><li>Ability to handle multiple tasks and prioritize work simultaneously</li><li>Demonstrate a detailed-oriented thought process with excellent documentation discipline</li>"}],"text":"Junior UX Writer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>It is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.</div>","descriptionBodyPlain":"About The Role\n\nIt is said that good design is good business. As our UX Writer for the Consumer Payments Product Design team, you'll dive deep into projects surrounding user experience, translating business goals, technical problems, and research points into impactful words/copy. With your stellar design-thinking, research, and data-driven capabilities, you’ll write for a range of audiences, produce multiple design point-of-views and solutions, conduct small to large research projects, and collaborate with a talented troop of writers and designers within the company.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d","applyUrl":"https://jobs.lever.co/GoToGroup/da1197ac-dfbc-4ad6-b215-2f2cd4939a0d/apply"},{"additionalPlain":"About the Team\n\nTransport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.\n\nDespite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Transport team owns the complete journey of a rider right from selecting pickup until the passenger is dropped off safely. We currently support bikes and cars as the transportation medium in 4 countries  -  Indonesia, Singapore, Vietnam and Thailand. Transport accounts for most number of transactions amongst all Gojek services.</div><div><br></div><div>Despite this scale we are still very early in our journey. You will join our iOS team and help us in taking Ride Hailing to the next level. </div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899257808,"descriptionPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","id":"f1d481f6-4e2d-401b-b310-fca641ab29d4","lists":[{"text":"What you'll do","content":"<li>Lead, mentor and recruit a team of highly talented and motivated engineers</li><li>Build and deploy features iteratively in production</li><li>Work cross-functionally with product, engineering and design teams across Gojek</li><li>Collaborate with internal teams to build and iterate on features</li><li>Build delightful user-facing experiences with smooth performance</li><li>Mentor and provide feedback to colleagues, participate in organisation building</li><li>Participate in research trips to better understand aspirations and pain points of our customers</li>"},{"text":"What you'll need","content":"<li>Should atleast have 6 years of relevant experience</li><li>Deep understanding of the iOS frameworks like UIKit, Foundation, etc.</li><li>Experience developing iOS apps in Swift</li><li>Attention to detail, particularly around software engineering fundamentals, testing methodologies, and quality</li><li>A strong customer focus</li>"}],"text":"Lead - iOS (Transport)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Senior iOS Engineers for the Transport team in Bangalore. This team in Gojek follows an interesting organisational structure which allows people to work on both vertical as well as horizontal products. You can choose to work on pick up experience across transport products or the end-to-end experience for our taxi product. You will work with teams in Jakarta, Bangalore and Singapore as well as our city teams across Indonesia.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4","applyUrl":"https://jobs.lever.co/GoToGroup/f1d481f6-4e2d-401b-b310-fca641ab29d4/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720610213311,"descriptionPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","description":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","id":"c9452ba2-cbb3-4ea5-83f7-79e765a67e58","lists":[{"text":"What You Will Do","content":"<li>As the Lead Auditor, you will support the design of risk-based audit plan influenced by regulatory compliance requirements, business needs and inputs from the governance teams (ERM, Ethics and Regulatory Compliance). You will deliver the audit as planned, discussion of issues with business and Group Audit, write up of report, advise and monitor on remediation progress. </li><div><br></div><div>Expectations of the role include: </div><div><br></div><li>Ability to deliver audit engagements independently and efficiently</li><li>Effective verbal and written communication (in Bahasa and English) of audit findings, remediation and reports to management.</li><li>Active participation and contribution to team discussion, audit planning, and stakeholder engagements.· &nbsp; </li><li>Ability to analyze operational process, regulatory issues and root cause.</li><li>Strong focus on quality deliverables such as audit report, work paper write ups, and presentation.</li>"},{"text":"What You Will Need","content":"<li>Mandatory: Minimum 8 years of audit experience obtained from public accounting and financial services internal audit roles.</li><li>Mandatory:&nbsp; Understanding and experience complying / auditing of relevant OJK regulations for multi-finance institutions.</li><li>Relevant certification in audit and risk preferred.</li><li>Highly motivated, demonstrated leadership attributes, meticulous attention to detail and problem solving</li><li>Effective communication in both Bahasa and English (verbal and written).</li><li>Ability to use data analysis tools (like ACL, MS Excel, Tableau, etc.).</li>"}],"text":"Lead Internal Auditor","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.&nbsp; You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.&nbsp; You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence.&nbsp;</div>","descriptionBodyPlain":"As the Audit Lead, you will be a valued member of GoTo’s Internal Audit Function and serve as the Lead for one for our Fintech product groups.  You will have an opportunity to learn and observe the innovative application of technologies to financial services and the dynamics of GoTo’s fintech product ecosystems.  You will interface with a team of pioneering business leaders, technologist and operation leaders and, through your audits, ensure that their work towards financial inclusion is in compliance with relevant regulations, policy and operational excellence. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58","applyUrl":"https://jobs.lever.co/GoToGroup/c9452ba2-cbb3-4ea5-83f7-79e765a67e58/apply"},{"additionalPlain":"About The Team\nOur data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n","additional":"<div><b>About The Team</b></div><div>Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, and Bangalore. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1719896801671,"descriptionPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","id":"4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","lists":[{"text":"What You Will Do","content":"<li>Manage data science infrastructure to streamline model development and deployment</li><li>Define and build scalable data pipelines that enables data scientists to build better models</li><li>Implement cutting edge big data frameworks to support batch and real-time jobs</li><li>Identify possible bottlenecks in the system and perform optimization</li><li>Build dashboards, models and deliver insights to support business analytics</li><li>Monitor and provide support to our infrastructure and production models</li><li>Mentoring team members through code review and knowledge sharing</li>"},{"text":"What You Will Need","content":"<li>At least 7 years of hands-on experience at large scales in data science / software engineering</li><li>Ability to write clean and structured SQL, Python and Shell programs</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Kubenetes, Docker, Infrastructure as Code, RDBMS and NoSQL Databases</li><li>Good understanding of machine learning techniques and algorithms</li><li>Good experience in serving real-time, production-level machine learning models</li><li>Management experience is preferred</li><li>Excellent communication skills</li>"}],"text":"Lead MLOps Engineer","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.</div>","descriptionBodyPlain":"About The Role\n\nAs a Lead MLOps Engineer, you must have a comprehensive MLOps skill set, experience as a data architect. Your job scope includes building machine learning pipeline and services, machine learning engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the MLOps services.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0","applyUrl":"https://jobs.lever.co/GoToGroup/4a16beae-3a6f-4dd4-9dc3-c98c1fa697b0/apply"},{"additionalPlain":"About the Team\n\nThe GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The GoCorp team focuses on building a platform to enables clients in managing their company expenses especially on the transport, food and logistics allowances. What we build is an infrastructure to help our clients use Gojek services for their business needs through many ways – enhancing GoCorp platform as well as external integration.</div>","categories":{"commitment":"Permanent","department":"ODS - Transport & Mobility","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718255937171,"descriptionPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","id":"8bf17375-6318-400f-8216-4a132071777a","lists":[{"text":"What You Will Do","content":"<li>Roadmapping → Establish strategic objectives, roadmap and timelines to guide the development and enhancement of the GoCorp platform</li><li>Focus on optimizing the client experience, ensuring the platform meets and exceeds user needs and expectations. Execute with precision make sure products and features are launched in timely manner</li><li>Seek product ideas and feedback based on both quantitative and qualitative date, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that one size doesn’t fit all and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Work closely with business, sales, and marketing teams to align product strategies and objectives. Ensuring the all teams runs with the same drumbeat&nbsp;</li><li>Ensure seamless coordination with other product teams connected to the GoCorp platform to maintain a cohesive product ecosystem</li>"},{"text":"What You Will Need","content":"<li>Proven experience if min 5-6 years in product management, preferably within a tech or platform-based company and B2B product</li><li>Strong strategic thinking and planning skills with the ability to set and achieve the mid term and long-term objectives</li><li>Data oriented – demonstrated an ability to balance between quantitative and qualitative data to optimize client experience.</li><li>Exceptional problem-solving skills with a proactive approach to overcoming challenges</li><li>Excellent collaboration skills with experience working across multiple departments</li><li>Proficiency in managing the entire product lifecycle, from concept to launch and beyond</li><li>Strong communication skills to articulate product vision and objectives effectively to diverse stakeholders</li><li>Solid understanding of the technical aspects of platform development and integration.</li><li>Fluent in written and verbal english</li>"}],"text":"Lead Product Manager, GoCorp","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for GoCorp platform at Gojek, you will be at the forefront crafting the product’s vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on optimizing clients experience, in alignment with the company’s goals. Collaborate extensively across various departments – business, sales, and marketing team as well as coordinate with the other products teams connected to the GoCorp platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a","applyUrl":"https://jobs.lever.co/GoToGroup/8bf17375-6318-400f-8216-4a132071777a/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1716776042348,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"4a126665-42d6-4a36-82a5-089dca789f41","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Nurturing &amp; mentoring 5-7 engineers members</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize their ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 7-8+ years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Leadership experience in leading a distributed team of software engineers</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>Working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, xgboost, Keras</li><li>Prior experience with cloud provider (GCP is a plus)</li>"}],"text":"Lead Software Engineer - Data Science Platform","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41","applyUrl":"https://jobs.lever.co/GoToGroup/4a126665-42d6-4a36-82a5-089dca789f41/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. About Courier team, we are responsible for running, developing and maintaining MQTT brokers which is one the largest MQTT cluster deployments in SEA. You are directly responsible for on developing and maintaining  open source mqtt broker, client libraries, tools and work with internal teams to integrate courier for various usecases across GOTO group.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719911495540,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","id":"a593bf17-baf2-479e-8154-c69d6a7d4f09","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost-effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems </li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure </li><li>Enhance code quality and product performance through continuous improvement and innovation </li><li>Collaborate and communicate effectively with teams across multiple geographies </li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves </li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices </li>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Erlang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with messaging protocol such MQTT &amp; prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Engineering Platforms","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable messaging platform. The platform you are building is designed to power diverse applications across Gojek's many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09","applyUrl":"https://jobs.lever.co/GoToGroup/a593bf17-baf2-479e-8154-c69d6a7d4f09/apply"},{"additionalPlain":"About the Team \n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. \n\nAt the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team </b></div><div><br></div><div>We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. </div><div><br></div><div>At the productivity team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</div><div><br></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1711535878605,"descriptionPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","id":"3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","lists":[{"text":"What You Will Do","content":"<li>Build and manage a highly scalable, reliable and cost effective application infrastructure at Gojek, forming the backbone of our diverse distributed systems</li><li>Be a role model in technical excellence, helping Gojek engineers deliver top-quality applications without worrying about underlying infrastructure</li><li>Enhance code quality and product performance through continuous improvement and innovation</li><li>Collaborate and communicate effectively with teams across multiple geographies</li><li>Share your knowledge and expertise to strengthen teams knowledge of the platform so they can support themselves</li><li>Regularly refactor your work to maintain high-quality design and architecture following industry best practices</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Atleast 7+ years of relevant experience . Hands on in any object oriented or functional programming language i.e. Java, Golang, Clojure, Python, Ruby etc building applications from scratch</li><li>Deep understanding of distributed systems fundamentals, large scale systems, observability stack, prometheus fundamentals, opentelemetry, container technologies, internet routing and load balancing</li><li>Experience in working with end to end Observability stack. Hands on experience in building and managing the telemetry pipeline at large scale</li><li>Experience in handling, scaling and optimizing high throughput systems</li><li>Prior experience with Grafana stack, Cortex, SLI/SLO platforms is a plus</li><li>Prior experience with AWS, GCP, Azure etc. is a plus</li><li>Deep knowledge of Linux as a production environment, container technologies. e.g. Docker</li><li>Working Experience with cluster orchestrators and schedulers (Kubernetes)</li><li>Experience with infrastructure automation tools like chef, ansible, helm</li><li>Have worked on production distributed systems and have an understanding of microservices architecture, RESTful services, CI/CD</li>"}],"text":"Lead Software Engineer - Observability","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>At Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nAt Engineering Platform, Gojek; we are looking for passionate engineers to join us in building a scalable platform-as-a-service (PaaS) on Kubernetes. The platform you are building is designed to power diverse applications across Gojek’s many business lines. Your expertise will be crucial in delivering a reliable, cost-effective, and enjoyable experience for the developers using our platform. If you enjoy creating tools for fellow developers and are comfortable dealing with high scale and complex distributed systems - this role will be a great fit.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a","applyUrl":"https://jobs.lever.co/GoToGroup/3ff4035e-6ad8-46c4-ac71-cf1fee12b49a/apply"},{"additionalPlain":"About the Team :\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</div><div><br></div><div>We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899083492,"descriptionPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","id":"9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences with minimal guidance for one of the world's fastest growing companies in travel</li><li>Understand, design and build to optimize in terms of resources used on the devices as well as simplify to meet the challenges of our always on-the-go users</li><li>Translate business requirements into scalable and extensible design</li><li>Partner with the product management team to define and execute the feature roadmap.Be responsible for defining and executing for complex, long term initiatives and help the team objectively lay out the roadmap and execute against smaller milestones</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Coordinate with cross functional teams (Backend, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence. Be the flag bearer for setting long term execution strategies and bring about the culture of operational excellence in the team</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in Android application development and product delivery</li><li>Predictability and balance of product delivery speed and quality</li><li>In depth knowledge of Android Apps architecture and implementation including proficiency in Kotlin, Architectural Components, Git, and Gradle</li><li>Understanding of TDD, Dependency Injection principles, Mobile Performance Tuning (Load time, Crash/ANR/Memory Leak tracking, Network optimisations)</li><li>Strong problem solving and analytical skills and a proven track record of being able to respond effectively to customer situations</li><li>A command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>A track record and passion for improving the code structure and architecture to improve testability and maintainability</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><div><br></div>"}],"text":"Lead Software Engineer - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>We are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.</div><div> In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class&nbsp; user experience and stability of our Android products.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nWe are looking for Lead software engineers for the Transport team, who will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products.\n In this role, your primary focus will be to technically lead design, develop and deploy android applications for some of the most critical and technically complex offerings that Gojek and should be passionate about maintaining a clean and maintainable codebase. Your ownership, drive and passion would help provide for a world class  user experience and stability of our Android products.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7","applyUrl":"https://jobs.lever.co/GoToGroup/9e0d8fd7-d416-49ee-8c0a-fcad22c923b7/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1704273923584,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","id":"2d3aae20-ff7e-4afb-8164-a351661c1680","lists":[{"text":"What You Will Do ","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest-growing company in the transportation industry&nbsp;</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Partner with the product management team to define and execute the feature roadmapCoordinate with cross-functional teams (Mobile, DevOps, UX, QA etc.) on planning and execution</li><li>Proactively manage stakeholder communication related to deliverables, risks, changes and dependencies</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building the next generation of Gojek services</li>"},{"text":"What You Will Need ","content":"<li>Should have at least 6 years of hands-on experience in designing, developing, testing and deploying applications on Java or Go for large scale applications</li><li>Proficient in System Design, OOP, SQL, Linux/Unix, and Design Patterns. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities, through self-discovery or by vouching for exploratory tasks</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback.</li>"}],"text":"Lead Software Engineer (IC) - Go-Food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. Your ownership, drive, and passion would help provide a world-class user experience and stability of Transport products for mobility or people and packages.\n\nWe are looking for Lead software engineers for the Transport team who appreciates good engineering and user experience. The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be technically leading the development and management of mission-critical systems.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680","applyUrl":"https://jobs.lever.co/GoToGroup/2d3aae20-ff7e-4afb-8164-a351661c1680/apply"},{"additionalPlain":"About The Team\n\nWe are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success\n\nWe're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>We are a high-spirited and dynamic team dedicated to achieving operational excellence within our business. Our approach is highly data-driven, with a strong emphasis on optimizing workflows to enhance overall business efficiency. Join us if you're passionate about driving measurable improvements in business processes and contributing to our success</div><div><br></div><div>We're a highly flexible team with a target-driven mindset. We manage our own work hours, so long as we deliver the expected results on time. As a team, we enjoy working at cafes (when it’s safe to do so), learning from and about one another, and having fun all along the way.</div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1721801286779,"descriptionPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","id":"ad8bd932-3494-4181-bd93-282665dce81d","lists":[{"text":"What You Will Do","content":"<li>Training Product Development: Develop and maintain detailed training materials, including manuals, user guides, and online resources, tailored to various audience levels. Collaborate with product managers, engineers, and other stakeholders to stay updated on product features and enhancements</li><li>Facilitation and Delivery: Conduct training sessions, both in-person and virtually, mainly for internal teams. Utilize a variety of instructional techniques and formats, such as role-playing, simulations, and interactive workshops</li><li>Assessment and Evaluation: Create and implement assessment tools to measure training effectiveness and knowledge retention. Gather feedback from trainees and use it to improve future training sessions</li><li>Support and Collaboration: Provide ongoing support and consultation to trainees post-training. Work closely with sales teams and internal stakeholders to address any training-related issues and ensure customer satisfaction to achieve business goals</li><li>Continuous Improvement: Stay current with the latest product developments and industry trends. Incorporate new training methodologies and technologies to enhance the learning experience.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or higher; majoring in Business, Economics, or relevant fields</li><li> 2 or 3 years of experience in a product training or related role within the tech industry. Has proven experience in developing and delivering training programs</li><li>Excellent presentation and communication skills</li><li>High attention to detail, has ability to explain complex technical concepts in a clear and accessible manner</li><li>Strong organizational and project management skills</li><li>Ability to adapt training methods to different learning styles and audiences</li><li>Ability to drive changes successfully and to keep people motivated in a highly changing environment&nbsp;</li><li>Proactive, ability to work in a team, and a strong can do attitude.</li>"}],"text":"Learning & Development Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires&nbsp; a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner.&nbsp;</div><div><br></div><div>In this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.</div>","descriptionBodyPlain":"About The Role\n\nWe are seeking a talented individual who is responsible for developing and delivering comprehensive training programs for our products. This role requires  a strategic thinker with strong communication skills, and the ability to convey complex technical information in a clear and engaging manner. \n\nIn this role, Trainer Lead will be responsible to design, implement, and manage comprehensive training programs that align with our business objectives and support employee development.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d","applyUrl":"https://jobs.lever.co/GoToGroup/ad8bd932-3494-4181-bd93-282665dce81d/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713944910535,"descriptionPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","id":"cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Proactively establish and strengthen relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia.</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals.</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors.</li><li>Project Leadership: Lead multiple projects in partnership with government institutions, focusing on Tech and the Digital Economy.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances.</li><li>Project Management: Oversee public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred.</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government.</li><li>Established network among government stakeholders with a proven impact on policy decisions.</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Manager of Food & Groceries Regulatory","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges.&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nThe individual will oversee regulatory matters impacting the food and grocery sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5","applyUrl":"https://jobs.lever.co/GoToGroup/cd0a57bb-9c5b-4d7d-bfd5-230d37b73db5/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719989851823,"descriptionPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","description":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","id":"ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","lists":[{"text":"What You Will Do","content":"<li>Maintain MI’s automation backend availability on Google Cloud Project&nbsp;</li><li>Continuously developing data pipeline architecture to ensure excellent performance&nbsp;</li><li>Do complex data analysis which are related to the Market Intelligence topics</li><li>Continuous knowledge update on latest tech capability to enhance the Market Intelligence deliverable in terms of depth, speed and variety of sources of references</li><li>Build and maintain a playbook for Market Intelligence data engineering projects</li>"},{"text":"What You Will Need","content":"<li>At least 2 years in <b>Data Engineer </b>roles</li><li>Talks in Python &amp; Linux</li><li>Exposure to data modelling would be preferred</li><li>Loves to experiment on the latest tech trends</li><li>Passionate in problem-solving and Root Cause Analysis (RCA)</li>"}],"text":"Market Intelligence (Data Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.</span></div><div><br></div><div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.&nbsp; Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are looking for a Market Intelligence Data Engineer to ensure all projects which involve heavy data, are delivered in the most efficient investment in terms of tools and time spent without sacrificing the robust framework and data validity. This person will be an integral supporter of the Market Intelligence Analysts by performing data processing automation, building data pipelines, and doing complex data analysis.\n\nAbout the Team\n\nThe Market Intelligence team works with various stakeholders from Corporate Strategy, Product, Pricing, Regions, and Marketing. It is a multidisciplinary team that aims to be the voice of the market by delivering insight and translating it into actions. Being aware of the industry's high pace, the team is always having high energy in exploring new ways of doing things more effectively.  Within this team, analytical thinking is a must, but creativity also defines how far we will keep going.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4","applyUrl":"https://jobs.lever.co/GoToGroup/ab96f280-f1d6-4ff7-bbe8-198ee4168bb4/apply"},{"additionalPlain":"Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.\n\nAs a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. \n","additional":"<div><span style=\"font-size: 9pt\">Mobility Marketing has its members divided into between the GoRide/GoSend and GoCar/GoCorp marketing team. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to ensure that we defend our position as the pioneer of online ride-hailing in Indonesia. How does one achieve this, you may ask? By creating an impactful and sustainable marketing initiative. What drives us is our shared vision to move people and goods anywhere, anytime by taking part in continuously educating people on how our product can change their lives, remove their daily frictions. We are working on several projects now, from innovation in GoCar services, like GoCar Hemat and GoCar Prioritas to GoCorp that allows the business whether it’s big or small to manage transportation and logistic costs in a more convenient and efficient way.</span></div><div><br></div><div><span style=\"font-size: 9pt\">As a team, we’re concerned with the growth of the company, and each other’s personal growth and well-being, too; we enjoy bonding over our shared love of workout routines, books, movies and any other hobbies. </span></div>","categories":{"department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720579532578,"descriptionPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","description":"<div><span style=\"font-size: 9pt\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","id":"967cfe0a-0243-4a2d-8813-038c355e43c3","lists":[{"text":"What you will do","content":"<li>Manage the marketing budget and ensure efficient allocation as well as prepare the report and regularly present it to senior management</li><li>Lead marketing metrics development, monitoring, and performance analysis periodically, as well as identify areas for <a href=\"http://improvement.Stay\">improvement.</a></li><li><a href=\"http://improvement.Stay\">Stay</a> updated on industry trends and the competitive landscape to inform strategic decision</li><li>Lead marketing campaigns development, monitoring, and evaluation incl. creative &amp; media strategy development &amp; execution with relevant stakeholders</li><li>Actively collaborate across functions &amp; streams especially product and strategy &amp; planning team in growing Transport business.</li><div><br></div>"},{"text":"What you will need","content":"<li>Bachelor's degree from a reputable university or equivalent practical experience</li><li>Min 4 years of experience working in a brand or product marketing field in FMCG, technology, telecommunication, or start-up</li><li>Excellent written &amp; verbal communication abilities at the business level with strong presentation skills to represent the Marketing team in functional meetings</li><li>Ability to work in a fast-paced, deadline-driven, and VUCA (volatile, uncertain, complex, and ambiguous) work environment</li><li>Strong capacity planning and reporting abilities; strong commercial sense and logical thinking skills to think outside the box as well as an understanding of budgeting, financial planning, and marketing <a href=\"http://metrics.Strong\">metrics.</a></li><li><a href=\"http://metrics.Strong\">Strong</a> analytical and quantitative skills; ability to use hard data and metrics to back up assumptions, and recommendations, and drive actions.&nbsp;</li><li>Familiarity with data analysis tools and software (SQL, Tableau, and Google Analytics)</li><div><br></div>"}],"text":"Marketing Planning Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.</span></div>","descriptionBodyPlain":"An exciting senior marketing role in one of the GOJEK core products, which is the pioneer of online ride-hailing in Indonesia is awaiting for you. If you’re looking to be a part of a dynamic, highly-analytical team and an opportunity to become marketing leader, look no further. As our Marketing Planning Manager for Transport, you will lead the marketing strategy for the Indonesia market from synthesizing the insights up to defining go-to-market and communication strategy while working closely with the Product Team and Strategy and Planning team to drive the demand and growth in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3","applyUrl":"https://jobs.lever.co/GoToGroup/967cfe0a-0243-4a2d-8813-038c355e43c3/apply"},{"additionalPlain":"About The Team\n\nOur Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media. \n\nAs a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Media Intelligence team consists of 4 people handling media analysis and research projects. Our main responsibility is to provide insights that drive our media strategy. How does one achieve this, you may ask? By continuously monitoring conversations of our brands and competitors both in conventional and social media.&nbsp;</div><div><br></div><div>As a team, we’re concerned with the company's growth and each other’s personal growth and well-being, too. We enjoy getting to know each other by talking about everything. For real, our weekly conversations range from social media trends to series worth binge-watching on the weekend. But whether you like movies or not, we’d be stoked to have you join the team!</div>","categories":{"commitment":"Internship","department":"HoldCo - Corporate Affairs","location":"Jakarta","team":"Media Intelligence","allLocations":["Jakarta"]},"createdAt":1719818000669,"descriptionPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","description":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","id":"a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","lists":[{"text":"What Will You Do","content":"<li>Monitor corporate news and other related information across channels (print, online, and social media).</li><li>Gather and analyze data from media monitoring to gain insights into public perception of the company and its performance.</li><li>Extract data and present interesting information from findings.</li><li>Identify trends and issues relevant to the company’s needs.</li><li>Collaborate to provide data-driven insights for other teams</li>"},{"text":"What Will You Need","content":"<li>Undergraduate students, preferably from Economics, Business, Computer Science, Marketing, Public Relations or Literature.</li><li>High proficiency in English and Bahasa Indonesia, both written and verbal.</li><li>A critical thinker, observant, and detail-oriented with vast knowledge of current issues and trends.</li><li>High willingness to learn.</li><li>Comfortable handling large data sets.</li><li>Knowledge in Ms Excel.</li><li>A collaborative team member as well as an independent self-starter.</li>"}],"text":"Media Intelligence Intern","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Join us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.</div>","descriptionBodyPlain":"About The Role\n\nJoin us to become a part of a collaborative, highly analytical team and an opportunity to dive deep into projects surrounding media analysis. As our Media Intelligence Intern, you’ll execute the daily media monitoring process for GoTo by enriching our database through data collection of corporate news and other related information from various media channels. The folks in Corporate Affairs team will be your companions on this ride. Your efforts will influence the direction of our media strategy. To deliver the tasks, you must be able to work full-time from Monday to Friday.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb","applyUrl":"https://jobs.lever.co/GoToGroup/a3de3e96-fc51-46e4-bcd4-f012f0d03bdb/apply"},{"additionalPlain":"About The Team\n\nThe management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.\n\nThe AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The management of AML-CFT in Subsidiaries which is under the coordination of the AML-CFT Special Work Unit. The implementation of the AML-CFT program is carried out by the AML-CFT Special Work Unit which is structurally under the Compliance Department and is directly responsible to the Director in charge of the compliance.</div><div><br></div><div>The AML CFT unit is a unique unit. We work in silence where everything has to be balanced between quality and speed. Where evidence must be supported by data and risk profiles. We must be able to understand the applicable laws and regulations, must always be up to date on the latest criminal cases or schemes related to ML, TF and PF and must be able to understand creative ideas from friends in Business and ensure they do not go off track . If you like watching FBI, CSI, NCSI series then you will definitely enjoy working in this unit.</div>","categories":{"commitment":"Permanent","department":"FinTech - AML/CFT","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719311112001,"descriptionPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","description":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","id":"f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","lists":[{"text":"What You Will Do","content":"<li>As an official directly appointed by the relevant Director and responsible for the implementation of AML CFT in the company.</li><li>A pointed person for any Regulatory Compliance matters/projects as well as internal or external auditors in compliance reviews.</li><li>As an industry expert, keep track of the latest developments around regulations and find smart solutions to mitigate ML/TF risks</li><li>Remain knowledgeable of new or changing regulations, regulatory expectations, market conditions, and industry best practices and find smart solutions to mitigate ML/TF risks</li><li>Ensure Subject Matter Experts participate in all activities where expertise is required, including but not limited to, risk assessments, policy writing, training development, advice to the business, monitoring activities, and reporting</li><li>Provide senior management with actionable advice on how to effectively manage AML/CFT-related risks</li><li>Ensure all regulatory reporting requirements related to AML/CFT themes are met</li><li>Ensure implementation AML CFT regular trainings as well to Business Unit and Support Function and to liaise with the Learning &amp; Development PAC;</li>"},{"text":"What You Will Need","content":"<li>A minimum of 5 years in this role in the AML/CFT</li><li>You have extensive knowledge of the payments and or the banking/finance industry</li><li>A thorough understanding of AML/CFT laws and regulations incl. risks, controls, industry best practices and regulatory requirements</li><li>An excellent and direct communicator who talks straight without being rude</li><li>You have the ability to clearly explain AML CFT compliance and related risks, develop sound mitigation strategies, and find workable solutions&nbsp;</li><li>You have extensive experience representing and leading meetings with regulatory agencies, examiners and auditors</li><li>You have the ability to structure and prioritize in a high-volume, fast-paced environment and drive a process to completion</li><li>You are a team player that does not shy away from taking ownership</li>"}],"text":"Merchants AML/CFT Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>This position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).</div><div><br></div><div>As AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).</div><div><br></div><div>Finally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.</div>","descriptionBodyPlain":"About The Role\n\nThis position is established to ensure the ongoing oversight and execution of the AML CFT implementation programs at PT MGR (PT Mapan Global Reksa).\n\nAs AML CFT Manager you are responsible for the day-to-day oversight of the AML CFT Unit, including the Expert staff and Transaction Monitoring. In this capacity, you will have primary responsibility for ensuring expertise is actively involved in processes related to risk assessment, policy development, training, advising, and reporting aspects of the Compliance program. Additionally, s/he will have primary responsibility for the design, implementation and execution of the (transaction) monitoring programs related to the expertise topics (AML CFT).\n\nFinally, as a member of the Compliance AML CFT Team, you will support other AML CFT and Compliance Managers in the day-to-day running of the department. The AML CFT Analyst must maintain working knowledge of all processes and procedures within the department in order to provide job coverage in the case of holidays, leave of absence or termination of employment of other managers within the Compliance AML CFT Department.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5","applyUrl":"https://jobs.lever.co/GoToGroup/f8ec8194-1eb5-4bdb-8419-a57a4966b1c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713245102772,"descriptionPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","description":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","id":"3f4f687f-8599-4d5c-96d5-8af234c3b09d","lists":[{"text":"What You Will Do","content":"<li>Identify and define business opportunities that aligns with the overall merchant services business objectives</li><li>Translate business opportunities into a fit problem statement and able to measure the priority of the problem&nbsp;</li><li>Collaborate with Product Team to develop a merchant focused product in onboarding and support&nbsp;</li><li>Develop Go-To Market plan and oversee the product adoption from funnel conversion rates and merchant experiences during the process.&nbsp;</li><li>Monitoring the product life cycle and continuously improved the product with a data driven decision making process</li><li>Engaged sales and ops team to deliver the best onboarding and support experience for merchants</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of working experience, experience in product and project management is a plus.&nbsp;</li><li>Possess a strong sense of agency in navigating and creating clarity in ambiguous situations.</li><li>Ability to break down complex problems, identify use cases and solutions, and thrive in unstructured environments.</li><li>Comprehensive understanding of data, design, research, and business processes, with the ability to effectively collaborate with diverse teams.</li><li>Strong analytical and quantitative skills, with the capability to utilize data and metrics to support requirements and features.</li><li>Effective communication skills to articulate strategy, insights, priorities, and plans coherently to all levels of management.</li><li>Meticulous attention to detail, with a commitment to upholding high standards and managing multiple, competing priorities concurrently with minimal supervision.</li>"}],"text":"Onboarding & Support Business Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment</div>","descriptionBodyPlain":"As a Business Lead for the Merchant Services Team in GoTo Financial, you will play a pivotal role as the driver for business growth and product go-to-market in Onboarding and Support pod. You will have the playground to deliver the best seamless experiences to onboard our merchants and provide a delightful in-app help experience for them. Throughout this experience, you will build relationships with product, operations, sales, design and research teams. The ideal candidate will have experience in business and product management, project management, excellent communication skills, and the ability to work independently in a fast-paced environment\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d","applyUrl":"https://jobs.lever.co/GoToGroup/3f4f687f-8599-4d5c-96d5-8af234c3b09d/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"Lending Operations","allLocations":["Jakarta"]},"createdAt":1720692666755,"description":"","descriptionPlain":"","id":"0ae5053b-3c5f-432a-9b69-b4cdefb01b79","lists":[{"text":"What You Will Do","content":"<li>Master all Consumer Lending Operations-related data points, including Customer Service, KYC, Telesales, and Transactional Data.</li><li>Manage all Operations Dashboards and Reporting to ensure timely and accurate availability.</li><li>Provide analytical insights leading to actionable plans with positive impacts for stakeholders.</li><li>Support the Head of Operation and other stakeholders in executing operational experimentation and enhancing workflow automation processes.</li><li>Lead, mentor and develop Operation BI team member.</li><li>Assist Operation stakeholders in dealing with Fraud investigation, Campaign Setup, and regulatory reporting and audit preparation</li><li>Analyze, evaluate, and initiate improvements in day-to-day operations for efficiency, effectiveness, and scalability.</li><li>Develop job automation to build Datamart-level tables in Big Query for Operational Dashboard Reporting.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's Degree in Engineering, Mathematics, Statistics, or a related discipline is required.</li><li>5 years of experience in a fast-paced environment, with a background in project management and data analytics.</li><li>Possesses strong analytical, planning, and problem-solving skills.</li><li>Proficient in SQL and Advanced Excel, with a high level of competence in working with numerical data sets. Knowledge of Python and experience in automating tasks is highly advantageous.</li><li>Familiarity with at least one business intelligence tool such as Google Data Studio (Looker), Power BI, or Tableau is preferred.</li><li>Ability to work independently with excellent time management skills, collaborating effectively with cross-functional teams to drive initiatives aligned with organizational objectives and Key Results (OKRs).</li><li>Exceptional communication and interpersonal skills, capable of articulating complex ideas to non-technical stakeholders with clarity and precision.</li><li>Familiarity with data warehousing concepts and methodologies is considered a plus.</li>"},{"text":"About The Team","content":"<li>Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</li><li>Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly. In the coming year, in light of our new GoTo collaboration, we have exciting plans to scale up our team in effort to field the massive growth of our data pool.&nbsp;</li>"}],"text":"Operation Business Intelligence Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79","applyUrl":"https://jobs.lever.co/GoToGroup/0ae5053b-3c5f-432a-9b69-b4cdefb01b79/apply"},{"additionalPlain":"Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy & Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs\n","additional":"<div><span style=\"font-size: 10pt\">Ready to join a team that shapes the future of new leading transformation in Gojek business as Fleet Strategy &amp; Planning and be the drivers of change in Indonesia's digital landscape? Join us and be part of something extraordinary in Driver Fleet process for our Mitra Driver needs</span></div>","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720522525041,"descriptionPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","description":"<div><span style=\"font-size: 10pt\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","id":"719f7a78-460a-4496-9298-ca57b835b120","lists":[{"text":"What you will do","content":"<li>Manage operational relationships with Fleet partners</li><li>Gain understanding of the mechanics of Fleet management, and identify pain points</li><li>Provide first level support for Fleet partners to ensure their business can thrive sustainably</li><li>Enhance the dynamic relationships among Gojek, Driver Partners, and Fleet Partners</li><div><br></div>"},{"text":"What you will need","content":"<li>A minimum of 3 years work experience in relevant sectors, e.g. Operations, Process Improvement and Management</li><li>Excellent problem solving and analytical skills</li><li>Great communication skills both in English and in Bahasa Indonesia</li><li>Strong sense of business and tech processes</li><li>Fast learner, can work in an ambiguous setting</li><div><br></div>"}],"text":"Operation Support Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.</span></div>","descriptionBodyPlain":"As Ops Support Manager, you will manage the business processes between fleet partners and Gojek. You will map existing processes, and improve upon it by automating and by scaling the support function. You will also build relationships and understand pain points from Gojek fleet partners, and solve it to build a sustainable Fleet ecosystem.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120","applyUrl":"https://jobs.lever.co/GoToGroup/719f7a78-460a-4496-9298-ca57b835b120/apply"},{"additionalPlain":"About The Team\n\nThe Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful experience.The Trust & Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and stakeholders.If you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust & Safety team.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Operations team executes and manages the day-to-day requirements of keeping Gojek up and running. We’re responsible for the overall experience of our community, and that everyone gets the utmost “Gojek” experience. In particular, we’re in charge of overseeing our driver-partner growth, retention, regulatory compliance and profitability targets, and ensuring that we offer our driver-partners and riders a delightful and meaningful </span><a href=\"http://experience.The\" style=\"font-size: 10pt\" class=\"postings-link\">experience.The</a><span style=\"font-size: 10pt\"> Trust &amp; Safety team is responsible for maintaining and improving the integrity of our platform by managing critical cases as well as proactively initiating campaigns to improve public trust. We operate on a 24-hour monitoring rhythm for all of our channels and are the first responders for incidents that may have a major business impact. The team is unwavering in its commitment to ensuring strict compliance with the dynamic regulations that govern the ride-hailing industry. Through ongoing vigilance and proactive measures, we contribute to fostering a secure and trustworthy platform for our users and </span><a href=\"http://stakeholders.If\" style=\"font-size: 10pt\" class=\"postings-link\">stakeholders.If</a><span style=\"font-size: 10pt\"> you are passionate about maintaining platform integrity, responding to critical incidents, and ensuring regulatory compliance in a dynamic environment, we welcome your application to join our dedicated Trust &amp; Safety team.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1708072107075,"descriptionPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","description":"<div><span style=\"font-size: 16px\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","id":"6f3368c9-6e84-489c-add3-4ad1fd4b9519","lists":[{"text":"What You Will Do","content":"<li>Provide regular analysis and reports on operational performance including compliance, escalations, quality, risk, and KPI tracking to guide decision-making and devise proactive solutions</li><li>Collaborate with cross-functional teams to build, automate, and improve on the availability, integrity, accuracy, and reliability of reporting, data logging, and data pipelines to be secure and compliant</li><li>Liaise with internal and external stakeholders for regulatory and compliance reports whenever needed, including issue investigation and report verification</li><li>Create and maintain performance management dashboards, visualizations, and trackers for Operations</li><li>Develop data-driven business insights and work with cross-functional teams to identify opportunities and implement new product features or system enhancements related to Trust &amp; Safety</li><li>Identify operational weaknesses and opportunities to help improve or innovate new processes and projects to drive user and vehicle quality, customer experience, and compliance to regulatory requirements</li><li>Prepare regulatory compliance reports to ensure adherence to relevant data protection, Insurance, earnings and safety regulations</li><li>Implement and maintain a good data management system to ensure the integrity, confidentiality, and availability of trust and safety-related data.</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in analytics and operations/compliance-related role</li><li>A wizard at working on and analyzing large datasets, with the ability to translate quantitative findings into action plan, demonstrated through understanding of&nbsp; statistical methods and modeling techniques.</li><li>Strong stakeholder and project management capabilities, with great attention to detail</li><li>Resilience and ability to take initiative in our constantly-changing fast-paced environment</li><li>Strong knowledge of SQL, Python, Google Suite, and MS Excel (advanced) is required</li><li>Experience in BI tools such as Tableau, Metabase, or Data Studio is a plus</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Operations Analyst, Data Operations (Trust & Safety)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust &amp; Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">Employing your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.</span></div><div><br></div>","descriptionBodyPlain":"If you’re looking to be part of a dynamic, highly-analytical team that works to keep the Gojek platform safe, look no further. As an Operations Analyst (Data Operations) for the Trust & Safety team, you’ll take the wheel in designing and building scalable analytics solutions to support regulatory compliance, drive user and vehicle quality, and improve platform reliability that empower the Singapore business. This role is central in ensuring strict compliance to the regulatory requirements of our operations. Working closely with the business, risk, product, and government relations teams, you'll dive deep into local market insights to provide direction and analytical solutions that are timely, accurate, and actionable to enhance the safety narrative and contribute to the continuous improvement of data pipelines within the business intelligence domain. \n\nEmploying your stellar analytical skills and contextual business acumen, your efforts will bolster the continuous improvement of our platform integrity aimed at further amplifying users’ trust perception of Gojek, ensuring a safe platform they can count on and love to come back to.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519","applyUrl":"https://jobs.lever.co/GoToGroup/6f3368c9-6e84-489c-add3-4ad1fd4b9519/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><span style=\"font-size: 10pt\"><b>About the team </b></span></div><div><br></div><div><span style=\"font-size: 10pt\">At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</span></div>","categories":{"department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721275390563,"descriptionPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","description":"<div><span style=\"font-size: 10pt\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","id":"03e3c5dd-2c14-4737-820e-f32b6cccf632","lists":[{"text":"What you will do:","content":"<li>Monitor and analyze key performance indicators (KPIs) to drive continuous improvement in operations.</li><li>Build and maintain strong relationships with merchant partners, promptly addressing their needs and concerns.</li><li>Train, mentor, and manage a team of onboarding specialists to ensure high performance and professional development.</li><li>Collaborate with internal teams to ensure drivers, merchants, and customers receive exceptional service.</li><li>Stay updated with industry trends and competitor activities to keep GoMart ahead.</li><li>Identify opportunities for operational efficiencies and implement best practices across the team.</li><li>Prepare routine reports and present findings as the basis of rationale and recommendations for strategic decision-making</li><li>Develop and implement strategies to enhance the onboarding process and improve merchant satisfaction.</li>"},{"text":"What you will need:","content":"<li>At least 5 years experience in operations, preferably at the managerial level and from Multi National Company</li><li>Strong analytical thinking, insights generating, and complex problem-solving skills using various improvement tools and methods, including Big Query/ SQL, Tableau</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds and ability to manage small team&nbsp;</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li><li>Fluent in Bahasa Indonesia &amp; proficient in spoken and written English</li>"}],"text":"Operations Manager - GoMart","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\"><b>About the Role :</b></span></div><div><span style=\"font-size: 10pt;\">Join GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia</span></div>","descriptionBodyPlain":"About the Role :\nJoin GoMart as an Operations Manager and help drive our exponential expansion! You'll be in charge of onboarding merchants nationwide and ensuring we provide exceptional service to our consumers. \n\nIn this role, you'll lead a team to engage with merchant partners, ensuring they receive a top-notch, end-to-end onboarding experience and can meet our expectations. In addition, you will work with internal stakeholders to ensure we are providing an exceptional experience to our drivers, merchants, and most importantly customers. Your efforts will directly contribute to our growth and success of the overall business.\n\nIf you're passionate about operational excellence, thrive in a fast-paced environment, and enjoy building strong partnerships, we invite you to apply and be part of our innovative team shaping the future of the grocery industry in Indonesia\n","hostedUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632","applyUrl":"https://jobs.lever.co/GoToGroup/03e3c5dd-2c14-4737-820e-f32b6cccf632/apply"},{"additionalPlain":"About the Team\n\nOur KYC team, a subsidiary of the Data Products and Infra Team , consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Operations, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers. \nWe are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our KYC team, a subsidiary of the Data Products and Infra Team , consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Operations, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers.&nbsp;</span></div><div><span style=\"font-size: 16px\">We are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"OneKYC","allLocations":["Jakarta"]},"createdAt":1722254499146,"descriptionPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n\n","description":"<div><span style=\"font-size: 16px\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div><div><br></div>","id":"c98e554f-20cd-4d37-80b7-46794ef7bedb","lists":[{"text":"What You Will Do","content":"<li>Managing both operations and project related KYC and KYB including but not limited to managing productivity and capacity plan for ops team both in house and in vendor, daily monitoring of team’s performance, staffing and work environment</li><li>PIC for vendor management both for MP and BPO, create a robust vendor scorecard to decide whether vendor will need to be replaced or not&nbsp;</li><li>PIC for complaint handling improvement for all issues related to KYC and KYB both for new users and existing users by considering the friction in the journey and cost optimization&nbsp;</li><li>Continuous cost and benefit analysis on the whole KYC and KYB process from Ops and Business perspective including but not limited to when leading projects or in day to day BAU</li><li>Identify key risks in the current lifecycle management process for various product under GoTo entity&nbsp;</li><li>Develop and implement AML related frameworks, policies and procedures&nbsp;</li><li>Liaise with OneKYC special project in implementing process improvement to improve quality or efficiency of key work in the KYC platform or other AML processes not supported by the KYC platform</li><li>Delivery on targets and objectives in line with timelines dictated by SLA's and quality expectations</li><li>Ensure preventive and detective KYC controls and monitoring programs are in place and provide adequate coverage by working closely with risk and fraud team&nbsp;</li><li>Taking a lead in KYC teams to generate the project plan including resource plan, prioritization, budget, test strategy in improving the current process or setting up a new one&nbsp;</li><li>Have flexibility and capability upon promoting project based on the Agile methodologies and supporting Scrum Master of development team</li><li>Manages the relationship and communications with key stakeholders across the Business, AML, Compliance, Risk, and product team in or outside GoTo</li><li>PIC for all audit related matters, be it internal and/or regulatory&nbsp;</li><li>Responsible for ensuring a seamless collaboration with all counterparts both internal and external of GoTo company.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A relevant Bachelor or Master Degree from reputable University</li><li>Should have at least 8 years of experience in a financial institution and have a background in leading big scale projects and process improvement with tangible result&nbsp;</li><li>Strong sense of operational risk and regulatory risk&nbsp;</li><li>Team player (adaptable, communicative, strategic, collaborative)</li><li>Analytical mindset (able to understand the context, find the correlation between topic, and draw the conclusion)</li><li>Problem-solving (able to link the information’s to solve the problem)</li><li>Experienced in creating BRD with the minimum point of problem statement, solution to implemented, cost and benefit analysis and impact analysis&nbsp;</li>"}],"text":"Ops and Project Manager - OneKYC","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div><div><br></div>","descriptionBodyPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb","applyUrl":"https://jobs.lever.co/GoToGroup/c98e554f-20cd-4d37-80b7-46794ef7bedb/apply"},{"additionalPlain":"About the team \n\nThe Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives. \nThe Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>The Payment PPGR team is part of the Payment Compliance team and is a critical unit in the GTF ecosystem, it acts as a point of contact between GTF-regulated entities with Bank Indonesia as the regulator. As part of the Payment Compliance team, the Payments PPGR team is obliged to ensure the adherence of internal divisions/units to payments system regulations, and at the same time to help ensure the business units are in a strategic position to execute all the business initiatives.&nbsp;</div><div>The Payment Compliance team itself combines youthful energy and responsibility as expected from mature individuals. We foster a healthy and conducive environment for the members to share their opinions and thoughts and we promote high responsibility for each task assigned to all team members. All of those are critical aspects for the team to be able to interact, make sound judgment, and give advice to many other functions within the GoTo ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Compliance","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721103093996,"descriptionPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","id":"90d1d8b9-75fb-4211-8d69-99412932f5ba","lists":[{"text":"What you will do","content":"<li>Work closely with business and support units to design and execute GoTo Financial payments advocacy.</li><li>Lead external engagements with Bank Indonesia, other regulators, industry associations, and other external stakeholders to advance GoTo Financial’s mission to provide accessible and safe payment products to all Indonesian users.&nbsp;</li><li>Support Compliance and Regulatory Affairs matters in GoTo Financial&nbsp; Payments Compliance operations, which includes but is not limited to business/product reporting and approval process with the regulators, and technical regulatory assessment</li><li>Create and maintain the latest update of payments regulations databases and provide/disseminate assessment on such regulations to the internal units in GoTo Financial</li><li>Any other ad-hoc duties that may be required.</li>"},{"text":"What you will need","content":"<li>Bachelor's Degree in Law/ Economics/Management/ Accounting and International Relations. Having a master’s degree would be an advantage.</li><li>At least 4 years of mixed experience in the area of public policy/public affairs, and/or regulatory compliance and past working experience in Bank Indonesia/ Otoritas Jasa Keuangan and Public Affairs consulting firms will be an advantage.&nbsp;</li><li>Advanced level of spoken and written skills both in English and Indonesian language.</li><li>Excellent analytical skills and attention to detail with the capacity to identify risks and proactively choose the best solutions and sound judgment.</li><li>Ability to multitask and adapt to work in a fast-paced team environment.&nbsp;</li><li>Well-developed communication skills (including oral, written, and interpersonal skills) and the ability to liaise and negotiate in a variety of contexts, including building credibility and strong relationships with internal and external stakeholders and counterparts</li>"}],"text":"Payments Compliance PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nThe Payments PPGR Manager is a strategic role within the GoTo Financial Payments Compliance division. As a mid-level manager of the team, she/he will be expected to support the GTF Head of Payments Compliance and Senior Manager PICs to ensure the alignment of GoTo Financial payments business with Bank Indonesia and other regulators' policy priorities. She/he will work across functions in GoTo Financial and GoTo Group to provide payments regulatory advisory assistance to all functions, design and execute payments advocacy strategies, and in doing so, collaborate with parties to expand and strengthen GoTo payments advocacies to external stakeholders.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba","applyUrl":"https://jobs.lever.co/GoToGroup/90d1d8b9-75fb-4211-8d69-99412932f5ba/apply"},{"additionalPlain":"\n","additional":"<div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - People & Culture","location":"Jakarta","team":"HR Information Systems","allLocations":["Jakarta","Singapore"]},"createdAt":1718958420176,"descriptionPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","description":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","id":"8fe35112-8410-4cf3-9a50-4c7287e95b57","lists":[{"text":"What You Will Do","content":"<li><b>HRIS Management &amp; Operations: </b>Operate and administer end-to-end Workday as our HRIS platform, serve as technical lead for Workday Core HCM, Talent Management, Absence, and Compensation. Provide technical support on day-to-day HR processes such as operations, payroll, performance management, and merit cycle. Act as a subject matter expert on HRIS-related inquiries and troubleshoot any technical issues that arise.</li><li><b>Process Improvement: </b>Identify opportunities to streamline HR processes using HRIS, automate manual efforts, and increase overall efficiency. Partner with cross-functional teams to identify opportunities for improvement, gather requirements, design, recommend, and implement system-driven solutions.</li><li><b>System Implementation &amp; Integration: </b>Collaborate with partners (HR and IT team) to configure and optimize HRIS modules, workflows, and integrate with other systems such as Payroll, ATS, and Finance to create seamless data flows. Lead HRIS system update and implementation of new HRIS modules, working with vendors and internal teams to plan and execute the process smoothly and successful adoption by stakeholders.</li><li><b>Report Development: </b>Develop and maintain custom reports, dashboards, and visualizations within HRIS to provide insightful HR metrics and analytics to stakeholders.</li><li><b>User Access Management and Compliance: </b>Manage user access and permissions to ensure data security and privacy compliance. Ensure HRIS compliance with relevant data protection and privacy regulations. Monitor and audit HR data to maintain accuracy, quality, and integrity, implementing necessary corrections and preventive solutions.</li><li><b>Training: </b>Provide training to HR staff and end-users on using and familiarities with the HRIS in respective to their roles.</li>"},{"text":"What You Will Need","content":"<li>Proven experience (typically 5+ years) in HRIS management and optimization.</li><li>Strong proficiency with Workday and related HR systems (Lever, Degreed, Larona, etc).Strong understanding of HR processes and workflows, with the ability to translate business requirements into HRIS solutions.</li><li>Excellent project management and problem solving skills, capable of handling multiple initiatives in a fast-paced environment.</li><li>Strong influencing skills with the ability to communicate clearly and confidently with stakeholders.</li><li>Strong managerial and leadership skills with the ability to guide, develop, and mentor team members to make things happen.</li><li>Experience communicating effectively across teams in markets across the region.</li><li><b>Preferred Qualifications: </b>Certification in Workday in one of the following modules: Core HCM, Advanced Compensation, Reporting, Talent, Performance, or Absence Management. Experience in SaaS HR system configuration. Experience with downstream system integrations such as Google Workspace, Google Cloud Platform, Workato, and JIRA/Asana.</li>"}],"text":"People Systems Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>GoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo.&nbsp;</div><div><br></div><div>This role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.</div>","descriptionBodyPlain":"About The Role\n\nGoTo is looking for an experienced, innovative, and highly driven People Systems Lead to drive the digitalization of our end-to-end HR ecosystem in GoTo. As People Systems Lead, you will be managing a team to operate, automate, and continuously improve our HR processes in GoTo. \n\nThis role will focus on digitalization, process improvement, and collaboration with various stakeholders, providing technical advisory, and system implementation to meet evolving HR needs.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57","applyUrl":"https://jobs.lever.co/GoToGroup/8fe35112-8410-4cf3-9a50-4c7287e95b57/apply"},{"additionalPlain":"About The Team\n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\n\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div><br></div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721379671434,"descriptionPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","description":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","id":"49388333-1938-4c06-b453-911eee08c53f","lists":[{"text":"What You Will Do","content":"<li>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. </li><li>Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis</li><li>Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</li><li>Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li>"},{"text":"What You Will Need","content":"<li>At least 3 years working experience in an analytical role&nbsp;</li><li>Proficiency in multiple analytic tolls with strong knowledge of SQL and experimentation process</li><li>Effective communication skills with the ability to present financial information clearly and concisely</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Strong business acumen with a data-driven approach to problem-solving and the ability to drive initiatives independently.&nbsp;</li><li>A confident communicator in verbal and written English</li>"}],"text":"Pricing & Supply Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Become a key player in scaling the GoMart business to new heights! As a Pricing &amp; Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations &amp; incentives.&nbsp;&nbsp;</div><div><br></div><div>If you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!</div>","descriptionBodyPlain":"About The Role\n\nBecome a key player in scaling the GoMart business to new heights! As a Pricing & Supply Associate, you'll be at the heart of our dynamic growth, reporting to key stakeholders, and collaborating with business and operations teams to identify customer pricing and driver allocations & incentives.  \n\nIf you have a passion for analytics and a drive to innovate, we want you on our team! Apply now and be part of our cutting-edge journey, shaping the future of the grocery industry in Indonesia!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f","applyUrl":"https://jobs.lever.co/GoToGroup/49388333-1938-4c06-b453-911eee08c53f/apply"},{"additionalPlain":"Our GoFood Strategy & Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. \n\nThe gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably. \n\nWhen our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 9pt\">Our GoFood Strategy &amp; Planning team is a family of 14 stationed in Jakarta Indonesia. As nasi goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">The gist of our responsibility is to design business strategies to help GoFood continuously grow and maintain its market leadership in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. For instance, to prioritize initiatives, we conduct market sizing efforts via methods that would give us a conclusion without having to ‘boil the ocean’. Our team is particularly driven by our shared passion to always deliver the best we possibly can, and (of course) our common love of good food. We are working on several projects now, including one about developing state-of-the-art mechanisms to lower our delivery cost, so that we can reach a wider customer base profitably.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 9pt\">When our laptops are shut, you'd probably find us engrossed in the latest blockbuster movies, whipping up new recipes in the kitchen, trying out delicious food spots in town (only when it's safe to do so!). We're a team that's equally concerned with the growth of our product as with each other's personal growth and well-being, as well.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721383021327,"descriptionPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","description":"<div><span style=\"font-size: 9pt\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","id":"0911a6fe-475a-498f-bf48-7d492e3d04d2","lists":[{"text":"What You Will Do","content":"<li><b>Strategize, experiment, and optimize: </b>Own key pricing &amp; supply objectives, defining strategy and rollout plan for pricing &amp; supply enhancements. Design and test scalable solutions and present the findings to senior management to drive business and strategic decision-making on feature prioritization and impact <a href=\"http://analysis.Execute\">analysis.</a></li><li><b><a href=\"http://analysis.Execute\">Execute</a> and collaborate: Collaborate with the data science team, product managers, public relations, government relations, finance, and legal to ensure that implementation of pricing enhancement can be implemented seamlessly end-to-end</b></li><li><b>Explore:</b> Continuously discover growth opportunities in business metrics by exploring Gojek’s vast data resources</li><div><br></div>"},{"text":"What You Will Need","content":"<li>BS/MS in Business, Engineering, Computer Science, Mathematics, Economics, Statistics, or equivalent experience</li><li>At least 4 years of working experience in an analytical role</li><li>Scientist thinking process that can work in increments and exponents, coupled with hypothesis-driven mindset</li><li>Proficiency in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with strong knowledge of SQL and experimentation process</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><div><br></div>"}],"text":"Pricing & Supply Senior Associate","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Roll up your sleeves and climb on board if you’re ready to be our next Pricing &amp; Supply Manager. In this role, you will be an integral player in the GoFood Strategy &amp; Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing &amp; incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing &amp; supply levers that will directly influence GoFood’s growth and profitability.</span></div>","descriptionBodyPlain":"Roll up your sleeves and climb on board if you’re ready to be our next Pricing & Supply Manager. In this role, you will be an integral player in the GoFood Strategy & Planning team based in Indonesia. By owning the levers such as customer pricing, driver pricing & incentives, and allocation, you will have to employ structured problem solving and think like a scientist to help GoFood maintain its market leadership in Indonesia, in a profitable way. In our humble opinion, the coolest part is your ownership towards pricing & supply levers that will directly influence GoFood’s growth and profitability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2","applyUrl":"https://jobs.lever.co/GoToGroup/0911a6fe-475a-498f-bf48-7d492e3d04d2/apply"},{"additionalPlain":"Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our data team is part of GoToFinancial Consumer Lending and mainly supports two products: GopayLater and GopayPinjam. The team includes members from offices in Jakarta, Singapore, Bangalore, and Beijing. We collaborate closely with the Risk, Finance, Growth, and Product teams, assisting them with their data requests on a daily basis.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1714372709159,"descriptionPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","description":"<div><span style=\"font-size: 10pt\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","id":"44117b68-3ece-40ac-91c1-920caadfe5dd","lists":[{"text":"What You Will Do","content":"<li>Design and construct scalable streaming or batch data pipelines to meet various business requirements.</li><li>Establish reliable monitoring and alerting systems to assess data pipeline performance.</li><li>Identify potential bottlenecks in the system and optimize as needed.</li><li>Manage the data science infrastructure to streamline model development and deployment.</li><li>Mentor team members by conducting code reviews and sharing knowledge.</li>"},{"text":"What You Will Need","content":"<li>Experience with streaming processing and Change Data Capture (CDC) tools such as Debezium, Flink, Kafka, etc. is necessary.</li><li>Good experience with infrastructure, including Cloud Computing, Linux OS, Networks, Docker, RDBMS, and NoSQL Databases is desirable.</li><li>Proficiency in Python and SQL is expected.</li><li>Must be self-driven, with a strong sense of ownership, and capable of working independently to solve problems and develop solutions.</li><li>Project management skills to successfully drive large-scale projects from initiation to completion are needed.</li><li>Excellent communication skills, including proficiency in English, are required.</li><li>Understanding of machine learning techniques and algorithms is advantageous.</li>"}],"text":"Principal Data Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser</span></div>","descriptionBodyPlain":"As a Principal Data Engineer, you must have a comprehensive data engineer skill set and experience as a data architect. Your job scope includes building streaming and batch pipelines and services, machine learning, and engineering support. You should be able to enhance the team’s tech stack, improving the reliability and efficiency of the data ser\n","hostedUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd","applyUrl":"https://jobs.lever.co/GoToGroup/44117b68-3ece-40ac-91c1-920caadfe5dd/apply"},{"additionalPlain":"About the Team - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.\n","additional":"<div><b style=\"font-size: 10pt\">About the Team</b><span style=\"font-size: 10pt\"> - GoPay Data Science team builds critical ML components/models which go into the engineering systems which make GoPay a safe, trusted and fun way to do payments. Our team members come from varied backgrounds, and bring with them a wide set of skills (mathematics, statistics, machine learning, deep learning etc) which we use some of the toughest business problems in GoPay. We are enthusiastic about both data science techniques and methods, as well as the business impact of our models, and have numerous internal forums where sharing, discussions and presentations by the team members happen.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721188007441,"descriptionPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","description":"<div><span style=\"font-size: 10pt\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","id":"0197001e-f39c-4d55-b6b9-1cf247bd17b0","lists":[{"text":"What You Will Do","content":"<li>Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactions</li><li>Rapidly prototype data science solutions and be involved in product and feature discussions</li><li>Analyze large volume data and generate insights which will be actionable</li><li>Own end-to-end solutions, from formulating the technical problem to deployment (along with engineers) of the solution</li><li>Participate in internal and external conferences and workshops</li>"},{"text":"What You Will Need","content":"<li>At least 8 years of relevant experience</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and demonstrated experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline</li><li>Experience in recommender system, ranking, multi-armed bandits, search and discovery is a plus</li>"}],"text":"Principal Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution</span></div>","descriptionBodyPlain":"Work as part of a cross-functional team of engineers, product managers and business analysts to build data science solutions that build customer engagement and help grow GoPay’s customer base and transactionsRapidly prototype data science solutions and be involved in product and feature discussionsAnalyze large volume data and generate insights which will be actionableOwn end-to-end solutioning, from formulating the technical problem to deployment (along with engineers) of the solution\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0","applyUrl":"https://jobs.lever.co/GoToGroup/0197001e-f39c-4d55-b6b9-1cf247bd17b0/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations.You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive. \n\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and </span><a href=\"http://automations.You\" style=\"font-size: 16px\" class=\"postings-link\">automations.You</a><span style=\"font-size: 16px\"> are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.&nbsp;</span></div><div><br></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Gurugram"]},"createdAt":1721890257186,"descriptionPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","id":"6f2d563a-182c-4c23-8c72-9d2a4f563ed9","lists":[{"text":"What You Will Do","content":"<li>Improves code structure and architecture in service of testability and maintainability</li><li>Has in-depth understanding of multiple programming languages/paradigms, and highly proficient in one technology area, including how it interacts with the system</li><li>Leads new language/framework POC within a technical focus area, participates in the design review process, and providing constructive criticism for improvement</li><li>Is accountable for the operationalization of the tracking and reporting of at least one execution metric (like code coverage, velocity)</li><li>Is accountable for ensuring that their squad has strong sets of documentations and journals of how their design and architecture evolves over time</li><li>Ensures predictability, quality &amp; throughput of their squad's delivery</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad's deliveryPrioritizes work based on understanding the trade-off between quality, tech-debt, and delivery</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: significant experience in one or many of the areas including golang/python programming, Events/stream processing framework development, engineering tooling and user facing interfaces, Kubernetes administration</li><div><br></div>"}],"text":"Principal Engineer - Cloud Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><br></div><div><span style=\"font-size: 16px;\">Gojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior &amp; Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\n\nGojek Cloud Platform team is looking for passionate technical leaders (Principal Engineer) with a drive of building scalable applications. You will interact very closely with Junior & Senior engineers within the team and leading the technical roadmap. On top of it, you will be the center of excellence for Cloud Platform related engineering for other team in Gojek.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9","applyUrl":"https://jobs.lever.co/GoToGroup/6f2d563a-182c-4c23-8c72-9d2a4f563ed9/apply"},{"additionalPlain":"About the Team :\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company. \n\nGojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div><span style=\"font-size: 11pt\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real time high throughput systems with a wide range of programming stack. At the Cloud platform team, we solve for the happiness of our customers who are Gojek Product Engineers. We do what we do by designing abstractions and automations. You are directly responsible for improving engineering quality and productivity and experience of engineers driving fundamental business KPI for the company.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 11pt\">Gojek is an equal opportunity workplace that is committed to diversity and inclusion. At Gojek we celebrate our differences, because we believe that diversity not only creates a healthier work environment for our employees, but also helps our business thrive.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721116359853,"descriptionPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","id":"7c3c43e3-8b8d-48a4-a590-7754207b2d1b","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, reliable and fault tolerant platforms for one of the world's fastest growing unicorns</li><li>You will be responsible for the overall delivery and the solution architecture of the offerings your team will be working on</li><li>You will own prioritization of initiatives to maximize achievements on objectives and growth for engineering at GoTo</li><li>You should understand product engineering and have empathy with problems and pain points of Product Engineers. &amp; you will continuously contribute to make their experience better</li><li>You shall write code because you like to. You never stop wanting to get better at it</li><li>Communicate, collaborate and work effectively with product teams distributed in a global environment</li><li>You will be responsible for the overall growth, learning and happiness of your team</li><li>Is independently responsible for coaching, development, and career management for the team</li>"},{"text":"What You Will Need","content":"<li>8+ years of hands-on experience in designing, developing, testing and deploying large scale applications in any language or stack&nbsp;&nbsp;</li><li>Have prior experience in managing cloud infrastructure GCP or AWS</li><li>Have experience in leading a team of 6-8 engineers and owning the overall delivery for the teams</li><li>Have done performance reviews for team members in the past and have worked towards giving them a growth path in their careers</li><li>Have experience with recruitments and staffing management to help in building a sustainable team</li><li>Can take recruitment and staffing responsibilities depending to balance out the growth</li><li>Continuously refactor applications and architectures to maintain high quality levels</li><li>Bonus point: Significant experience in one or many of the areas including Clojure programming, Stream processing framework development, engineering tooling and user facing interfaces</li>"}],"text":"Principal Software Engineer","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div><span style=\"font-size: 11pt;\">At the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. </span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAt the Cloud Platform team in Engineering Platform, Gojek we are looking for passionate, entrepreneurial technical leaders with a drive of building scalable applications and teams. In this role you will be responsible for the overall success and growth of your team. You will interface very closely with stakeholders across engineering leadership and will have ownership of building cutting edge PaaS solutions aimed at improving engineering experience at Gojek. Engineering Manager is a leadership role, in which direct reports are Senior Engineers and Technology Leads of the team. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b","applyUrl":"https://jobs.lever.co/GoToGroup/7c3c43e3-8b8d-48a4-a590-7754207b2d1b/apply"},{"additionalPlain":"About the Team\n\nOur Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport PDG team is part of GoJek GoTo family that includes engineers, product managers, designers etc spread out across Bangalore, Gurgaon, Jakarta and Singapore. We run Southeast Asia’s leading ride-hailing business and oversee all things related to our riders and driver-partner's needs. We touch millions of lives on a daily basis through our ride-hailing experience and continuously work towards trying to improve the experience for our customers and driver partners. It’s our job to ensure that our Transport services run seamlessly from inside out.</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing games or catching up with each other and discussing varied topics. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1715060912791,"descriptionPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","id":"426f18b4-739e-4da0-a74b-446c349c0a31","lists":[{"text":"What You Will Do","content":"<li>Design and develop highly scalable, highly available, reliable, secure and fault tolerant systems with minimal guidance for one of the world's fastest growing company in the transportation industry</li><li>Translate business requirements into scalable and extensible design</li><li>Pair with team members on functional and nonfunctional requirements and spread design philosophy, goals and improve the code quality across the team</li><li>Collaborate with cross functional teams (Mobile, DevOps, UX, QA etc.) on execution and delivery</li><li>Partner with the team to define and execute the feature roadmap</li><li>Provide technology leadership to the team and foster engineering excellence</li><li>Research new technologies and tools that enable building simplistic architecture for the next generation of Gojek services</li>"},{"text":"What You Will Need","content":"<li>Should have at least 7 years of hands-on experience in designing, developing, testing and deploying applications at scale</li><li>Proficient in System Design, Design patterns, database structure, Linux/Unix. Experience with functional programming and infrastructure management is a plus</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimizations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to pick up new technologies and independently navigate obstacles and find innovative solutions</li><li>Ability to seamlessly switch focus between tasks and enthusiasm for seeking out learning opportunities</li><li>Ability to build strong relationships within and beyond the team, enhancing knowledge expansion and problem-solving efforts, while also nurturing the same through the exchange of constructive feedback</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Principal Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for Principal Software Engineers for the Transport team. As part of this role you will be responsible to raise the bar for engineering excellence and set up practices that would enable the next evolution of the products. You will need to be hands-on with the technology and curious to learn and unlearn. Your primary focus will be to technically lead design, develop and deploy some of the most critical and technically complex offerings at Gojek. You should be someone who is passionate about maintaining a clean and maintainable codebase. In this role you would also be forthcoming to mentor and guide peers towards technical know-hows and help in ideating towards a simple but more scalable approach for complex workflows. Your ownership, drive and passion would help provide for a world class user experience and stability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31","applyUrl":"https://jobs.lever.co/GoToGroup/426f18b4-739e-4da0-a74b-446c349c0a31/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719211012411,"description":"","descriptionPlain":"","id":"fc7c3413-6c4f-42bd-a048-70387bd490a4","lists":[{"text":"What you will do:","content":"<li>Process Analysis and Assessment: 1. Conduct comprehensive assessments of existing business processes to identify inefficiencies, bottlenecks, and areas for improvement. 2. Gather and analyze data to understand process performance and identify root causes of issues. 3. Develop process maps, flowcharts, and other documentation to visualize current state processes.</li><li>Improvement Strategy Development: Collaborate with stakeholders to design and develop strategies for process improvement, focusing on enhancing efficiency, quality, and customer satisfaction.</li><li>Implementation of Improvements: 1. Lead cross-functional teams in the implementation of process improvements, ensuring alignment with business goals and objectives. 2. Develop &amp; monitor detailed project plans, timelines, and milestones to guide improvement initiatives.</li><li>Change Management and Communication: Drive change management efforts &amp; communicate effectively to ensure smooth adoption of new processes and practices.</li><li>Performance Monitoring and Reporting: 1. Establish key performance indicators (KPIs) to measure the effectiveness of process improvements. 2. Conduct post-implementation reviews to assess the impact of changes and identify further improvement opportunities.</li><li>Continuous Improvement Culture: Provide mentorship and guidance to stakeholders on process improvement methodologies and tools.</li>"},{"text":"What you will need:","content":"<li>Bachelor's degree in Business Administration, Industrial Engineering, Operations Management, or a related field. A Master's degree is preferred.</li><li>Proven experience in business process improvement, process engineering, or related <a href=\"http://roles.Strong\" class=\"postings-link\">roles.</a></li><li>Strong knowledge of process improvement methodologies (e.g., Lean, Six Sigma, Kaizen).</li><li>Excellent analytical and problem-solving skills.</li><li>Exceptional project management skills, with experience leading cross-functional teams.</li><li>Strong communication and interpersonal skills, with the ability to influence and drive change.</li><li>Proficiency in process mapping and analysis tools (e.g., Visio, Lucidchart).</li><li>Ability to manage multiple projects and priorities in a fast-paced environment.</li>"},{"text":"Preferred Skills:","content":"<li>Fluent in English&nbsp;</li><li>Experience with data analysis tools (e.g., Excel, Tableau, Power BI).</li><li>Knowledge of change management principles and practices.</li><li>Familiarity with ERP and CRM systems, especially Salesforce</li><li>Experience in training and development related to process improvement.</li>"}],"text":"Process Improvement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4","applyUrl":"https://jobs.lever.co/GoToGroup/fc7c3413-6c4f-42bd-a048-70387bd490a4/apply"},{"additionalPlain":"About The Team\n\nGoTo Procurement  Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.\n\nAs a team, we are not only concerned about the company but also the professional and personal growth & aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things\n","additional":"<div>About The Team</div><div><br></div><div><span style=\"font-size: 10pt\">GoTo Procurement&nbsp; Team consists of 40 people based in Indonesia. The gist of our role is to contribute to annual cost optimization within GoTo following the GoTo Procurement Policy and build strong relationships both with internal stakeholders and vendors. We collaborate alongside many teams across the organization.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we are not only concerned about the company but also the professional and personal growth &amp; aspiration of each team member. In order to help such that, we have regular professional development sessions and bonding sessions to help improve the legal acumen of our members and take some time off to bond over our shared love for delicious food, movies, and songs, among many other things</span></div>","categories":{"department":"HoldCo - Finance","location":"Jakarta","team":"Procurement","allLocations":["Jakarta"]},"createdAt":1721729730710,"descriptionPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","id":"c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","lists":[{"text":"What Will You Do","content":"<li>Lead and execute the Vendor Selection process to ensure that the company is getting what it really needs as well as the best deal in the market, following GoTo Procurement Procedure while adhering to relevant Policies and Procedures within the organization and collaborating with the relevant stakeholders and Subject Matter Expert (SME) to support comprehensive evaluation. The vendor selection process will be for both Tactical and Strategic bidding and aim for cost optimization targets and ensure the proper documentation to establish transparency and accountability</li><li>Drive cost optimization initiatives to support organization operating cost optimization through the execution of Procurement activities, including mitigation of any relevant risks within the Source-to-Pay process and supply chain.&nbsp;</li><li>Owning the Source-to-Pay process by ensuring a seamless transition throughout the steps, starting from capturing business needs up to Vendor Payment</li><li>Increase Procurement’s technology and platform utilization and target for SLA optimization and Sourcing Quality</li><li>Develop a Sourcing competencies framework as part of people development within the Procurement Sourcing organization</li><li>Build the right vendor market and network as well as internal stakeholders, to support the collaborations within Procurement processes</li><li>Lead and collaborate Vendor Value Creation Program together with Critical/Valued vendors to deliver innovation, better speed to market, productivity, asset utilization, sustainability, etc.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>Bachelors of business, supply chain management, or any other related field. Preferably has been working in Procurement too</li><li>At least 2 years in procurement areas, preferably from multinational companies</li><li>Strong business and commercial mindset</li><li>Excellent negotiation, organizational, and collaboration skills</li><li>Excellent interpersonal and communication skills</li><li>Excellent project management skills</li><li>Advanced in verbal and written English proficiency</li>"}],"text":"Procurement Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.</div><div><br></div><div>You’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.</div><div><br></div><div>They say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.</div>","descriptionBodyPlain":"About The Role\n\nAs our Procurement Specialist in GoTo, you’ll be an integral player within the GOTO Procurement team based in Jakarta. We oversee everything related to the Procure to Pay (P2P) process to support Goto Business in Jakarta. Specifically, we do sourcing activities that relate to goods/ services in several categories with the nature of procuring Technology/IT Infrastructure commodity and working with cross-business units who require the such products/ services nature.\n\nYou’ll be a single contributor in handling the assigned sourcing activities. If you’re looking for a chance to hone a skill vertically and horizontally, Procurement is the right place to learn it. You’ll employ your skills and experiences to add more power to enrich the team’s strategy and project fulfillment.\n\nThey say no man is an island, and this notion holds particularly true for this role. As our Procurement Specialist, you’ll be part of the Procurement team that directly liaises with Goto’s stakeholders. Your main objective will be to look after the full spectrum of sourcing activities for a variety of portfolio vendors. Best yet, you’ll have the opportunity to flex your negotiation and management skills, getting us even closer to our ultimate goal of consistent and efficient earnings stability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274","applyUrl":"https://jobs.lever.co/GoToGroup/c108cfcc-f80d-4f3d-b4a7-ff3deb1b4274/apply"},{"additionalPlain":"About the Team\n\nThe Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.\n\nWe have helped simplify payments for over 750,000 merchant partners, over  1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Payments team in Gojek spans both customer payments (GoPay e-money and wallet) and merchant payments (online payments via Midtrans). Midtrans is one of the largest payment gateways in Indonesia. Spots is the largest offline network for payments in Indonesia.</div><div><br></div><div>We have helped simplify payments for over 750,000 merchant partners, over&nbsp; 1,000,000 driver partners, and millions of customers - from the bike drivers down your street to your favorite Gorengan and Martabak stalls. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1720599307040,"descriptionPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","description":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","id":"83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","lists":[{"text":"What You Will Do","content":"<li>Conduct merchant research and analyze user data to identify trends and pain points.</li><li>Working with Business Intelligence teams, writing queries and learning to set up product metric tracking dashboards&nbsp;</li><li>Help summarize merchant interviews as insights</li><li>Collaborate with product managers and designers to define product requirements.</li><li>Develop and present product recommendations based on data analysis.</li><li>Assist with creating product prototypes and user testing.</li><li>Stay up-to-date on industry trends and competitor analysis.</li>"},{"text":"What You Will Need","content":"<li>Strong analytical skills with proficiency in data analysis tools, candidates with experience will be preferred</li><li>The ability to write SQL queries is strongly preferred</li><li>Excellent communication and presentation skills.</li><li>A passion for product development and a keen eye for detail.</li><li>Familiarity with the Indonesian payments landscape is a plus.</li>"}],"text":"Product Analyst Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>At GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.</div>","descriptionBodyPlain":"About the Role\n\nAt GoTo Financial, thousands of merchant partners rely on us for their payment infrastructure needs. As a Product Analyst Intern, working with the product, design, and engineering team, you will play a key role in supporting the growth of our product offerings. You will assist with analyzing user and product data, identifying merchant needs, doing market research for new potential product launches, and developing product recommendations to enhance the Midtrans user experience. Working with the head of product, you’ll break down complex issues into actionable steps forward to optimize our product. Your efforts will further position Midtrans as the hub for all digital payments and transfers made by businesses in Indonesia, solidifying Midtrans’s position as the leading payment gateway in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8","applyUrl":"https://jobs.lever.co/GoToGroup/83c662d2-4a1e-40ca-a2d3-daf2a1b102b8/apply"},{"additionalPlain":"About The Team\n\nThis vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.  \n\n","additional":"<div><b>About The Team</b></div><div><br></div><div>This vital team within GoTo Financial is dedicated to serving businesses of various scales and enabling their productivity with technology and a high caliber of service. The team comprises passionate, welcoming, vibrant, and talented people from Indonesia and around the world. When they are not working, they spend time hanging out together, sharing their interests, and regularly meeting outside of work for games and meals. You will be tightly integrated into GTF Merchant Services: Design, UX Writing, and Research team of 9+ practitioners; who are there to drive merchant centricity and empathy towards our users. You will work alongside 1 research manager, product and business heads, while directly reporting to the head of the offline merchant business.&nbsp;&nbsp;</div><div><br></div>","categories":{"department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1718084687109,"descriptionPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","description":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","id":"a1ebb8d4-0af0-4707-9efb-8f52aa781c44","lists":[{"text":"What You Will Do","content":"<li>Help define the roadmap, goals, and vision for the product experience</li><li>Work with design leads, product heads, marketing and engineers to build/improve user experience and ways of working towards that vision</li><li>Manage projects, solve complex problems, and enable your team to deliver delightful solutions that drive impact</li><li>Build systems for design documentation &amp; help establish processes to ensure seamless collaboration</li><li>Mentor and coach a team of designers, improve stakeholders grasp and application of design thinking</li><li>And most importantly, make sure your team is engaged well and building things that make them successful</li>"},{"text":"What You Will Need","content":"<li>At least 6 years of experience in product design, but still willing to learn more about product research</li><li>Proficiency in all areas of digital product design; visual design, user experience design, user research prototyping, advocacy and building showcases. Additional exposure to motion, sound, video and other craft are welcome</li><li>Ability to draw insights from both qualitative &amp; quantitative data, and further identify problem areas to work on.</li><li>Ability to design, advocate and prioritize user research with our research team</li><li>Knowledge in design fundamentals, such as design thinking frameworks, HCI principles, and being able to take on a structured approach in solving problems</li><li>Excellent organizational, project management, and collaboration skills to manage a wide range of stakeholders</li>"},{"text":"","content":"<li><br></li>"}],"text":"Product Design Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>Are you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.</div><div><br></div><div>The creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nAre you someone who's looking to solve problems that matter? Are you someone who thrives on the balance of business goals and users' needs? Are you looking for the opportunity to nurture bright minds? We have good news for you.\n\nThe creators of GoPay (Goto Financial) are looking for a Design Manager to join us on an adventure to head the design team responsible for Moka, Midtrans and GoPay merchants. We're offering a playground to experiment and ship exceptional solutions to a diverse set of problems ranging from typical UX design, to service design and sound design. You'll be working with other leaders to define the roadmap, goals, and vision of the products and spearhead the stride to deliver exceptional user experiences. Your team will impact tens of millions of GoPay users and merchants who use our products daily to make a livelihood. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44","applyUrl":"https://jobs.lever.co/GoToGroup/a1ebb8d4-0af0-4707-9efb-8f52aa781c44/apply"},{"additionalPlain":"About the Team\n\nThe Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. \n\nWe’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers. \n\nThe Loyalty, Incentives & Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more. \n\nWe are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .\n\n\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Gojek Design Team is made up of around a hundred designers spread across two countries and seven teams. Our members come from a wide range of backgrounds and are experts in Graphic Design, Interaction Design, Product Design, UX Writing, Illustration, Service Design, UX Research, and Motion Design. Together we envision, create, and support products and services that meaningfully improve the lives of our customers. </div><div><br></div><div>We’ve come a long way since 2015 when we were a small central team of 15 designers working to build and support products that were scaling at an unprecedented rate. Since then, we’ve grown with the rest of the organization in bringing to life over 24 different products. Various obstacles presented themselves, from the actual design process, ensuring we weren’t a bottleneck, to fostering a design-based philosophy throughout the company. Since then, we’ve been educating everyone around us on the importance of design, and why it makes sense to start with the users and work backwards. We’ve continuously evolved our design processes, improved the quality of our outcomes, expanded our reach within the organization, and relentlessly advocated for our customers.&nbsp;</div><div><br></div><div>The Loyalty, Incentives &amp; Monetization Platform enables various product groups to provide delightful discounting and incentivization experiences to customers via sustainable and scalable product solutions. Our mission is to create sustainable reward systems to give consumers (and partners) reasons to use Gojek more.&nbsp;</div><div><br></div><div>We are responsible for the core user flows and experience in rewards, promotions and loyalty programs for our end customers, including the efficacy for incentive-based campaign management tools and services. Our product suite currently includes GoClub (our newest loyalty program), promotions pages and comms, and various discounting and growth levers such as vouchers, referrals, etc .</div><div><br></div><div><br></div>","categories":{"department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718798053606,"descriptionPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","id":"e407433b-435a-4607-89bd-5faf51cf622e","lists":[{"text":"What You Will Do","content":"<li>Work closely and under the supervision of a senior product designer, and follow the predefined process set forth by the team</li><li>Able to comprehend the product briefs and be able to present the ideas/solutions to the team under the supervision of the product design lead</li><li>Effectively deliver features and improvements in a well-defined scope</li><li>Define end-to-end wireframe and wireflow for features using standard wireframing tools</li><li>Document the design process for each feature, such as research findings, ideations, usability tests, release, and monitor the impact after the product release</li><li>Contribute to the team cadence discussion and make occasional short presentations to the team, as well as present team’s updates if needed</li><li>Proactively seek/give feedback from other stakeholders to make sure concepts are meeting the intended project goal</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of relevant experience in the product design industry</li><li>Familiar with data and can identify problem areas, further map out the user journey, and break the problems into smaller chunks</li><li>Use basic analytics tools to gather customer data (funnel)&nbsp;</li><li>Possess a good knowledge of design fundamentals, such as design thinking framework and other frameworks to develop products</li><li>Able to sketch the ideas into wireframes, learn how to make wireflow, and do wireframing for well-defined features</li><li>Good knowledge of the tools, such as Overflow, Miro, Sketch, Figma, or similar ones that are widely used by Product Designers</li><li>Knowledge of design validation, either through quantitative or qualitative research</li><li>Preferably some knowledge of service design and experience with working on mobile app design</li>"}],"text":"Product Designer - Food","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Include challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nInclude challenges, scope of the role, and impact the person will have during the first 6 months)As a Product Designer for the GoFood consumer team, you'd be helping build the GoFood at its very core. Get ready to explore problems from users' visible/ invisible needs and evident pain points to shape nuanced experiences. You’d be solving problems that affect the many ways customers interact with GoFood while making their experience fast, reliable, and easy. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e","applyUrl":"https://jobs.lever.co/GoToGroup/e407433b-435a-4607-89bd-5faf51cf622e/apply"},{"additionalPlain":"About The Team\n\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. The Growth Platform team focuses on customer activation and retention on Gojek. We build custom product journeys to help users smoothly onboard into Gojek and to continuously engage their customers by providing the best experience.&nbsp;</div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718166115141,"descriptionPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","description":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","id":"b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirements and the impact of each feature, as well as the go-to-market strategy to ensure adoption of the features</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in product management experience</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Growth","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>About the Role</div><div><br></div><div>As a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders&nbsp; and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nAs a Product Manager for Growth Platform at Gojek, you will be at the forefront of crafting the product's vision, defining features, collaborating with stakeholders  and steering the realization of this vision with a focus on optimizing customer experience on Gojek Home page. In this role, you will be collaborating extensively across various departments, you will liaise with business, marketing, engineering and data teams, as well as coordinate with other product teams connected to the Growth Platform. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba","applyUrl":"https://jobs.lever.co/GoToGroup/b1b7f5c3-3cd3-47f9-919c-7ca422b498ba/apply"},{"additionalPlain":"About The Team\nJoin Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology. \n\nThe Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.\n","additional":"<div><b>About The Team</b></div><div>Join Gojek's Product Management team, a hub of innovation and collaboration, to revolutionize everyday experiences at scale, while embracing a culture that values creativity and meaningful impact. We welcome people from all backgrounds who seek the opportunity to help build a future where everyone and everything can move independently. If you have the curiosity, passion for technology, and collaborative spirit, work with us and let's solve the problems with technology.&nbsp;</div><div><br></div><div>The Logistics Platform team at Gojek oversees all aspects of package delivery, from developing APIs for our B2B product line to solving intracity peer-to-peer delivery for Gojek users. Our team is dedicated to enhancing the experience for both customers and driver partners while continuously exploring new growth opportunities.</div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719305116114,"descriptionPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","id":"6f05ee4a-fa49-4aca-8990-c6607cd7cf09","lists":[{"text":"What You Will Do","content":"<li>Deliver. You do more than talk - you put things on paper, get your hands dirty, and execute with precision make sure products and features are launched&nbsp;</li><li>Seek product ideas and feedback, gather requirements, write specs, create wireframes and workflows, and demo them early and often</li><li>Understand that “one size doesn’t fit all” and conceptualize solutions that are configurable and adaptable to the maximum extent possible</li><li>Giving clarity to the product development group and stakeholders on the requirement and the impact of each feature as well as the go to market strategy to ensure adoption of the features.&nbsp;</li><li>Using data to analyze each feature's adoption and impact, while making improvements on the features to solve merchants' pain points</li><li>Develop strong relationships across stakeholders to understand their goals and priorities. Work with these stakeholders to help them convert these goals into reality</li><li>Define, prioritize and plan the product features that will need to be implemented, through alignment with all stakeholders</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of total experience, with 2-3 years experience specifically in product management</li><li>Critical and analytical thinking ability</li><li>Experience working on Objectives and Key results model of goal setting</li><li>Data-oriented with excellent analytical skills; Able to dig into data to discover nuances, and define &amp; measure success on every project. Prior experience with experimentation is a strong plus</li><li>Strong strategic planning and organizational skills</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding &amp; information exchange across all stakeholders</li><li>Be able to work with agile product development teams and identify new ways to help your team be productive. Experience of working with distributed teams is desired</li><li>Fluency in written and verbal English</li>"}],"text":"Product Manager - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.</div>","descriptionBodyPlain":"About The Role\n\nAs a Product Manager for Logistics platform at Gojek, you will be at the forefront of crafting the product's vision, setting strategic objectives and timelines, and steering the realization of this vision with a focus on growing the logistics business , in alignment with the company's goals. Collaborating extensively across various departments, you will liaise with business and sales teams, as well as coordinate with other product teams connected to the logistics team.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09","applyUrl":"https://jobs.lever.co/GoToGroup/6f05ee4a-fa49-4aca-8990-c6607cd7cf09/apply"},{"additionalPlain":"About The Team\nWork hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Work hard, play hard together! Join us as we’re fun-loving, collaborative, and inclusive!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721026583842,"descriptionPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","id":"92f4b266-849a-42f2-b7e0-859360a003d8","lists":[{"text":"What You Will Do","content":"<li>Develop and own end-to-end project and program plans that outline scope, goals, deliverables, required resources, and timelines&nbsp;</li><li>Monitor progress of projects and programs to highlight plan deviations,, resolve issues and propose corrective actions to remove implementation blockers</li><li>Oversee and synergise multiple projects to ensure prompt completion within scope, and within budget</li><li>Work closely with internal and external stakeholders from cross-functional teams to assess feasibility of initiatives, develop the scope, and deliverables</li><li>Act as a point of escalation for project and program initiatives’ issues, mediate issues, and ensure stakeholder’s expectations are met</li>"},{"text":"What This Role Needs","content":"<li>At least 3 years of work experience in the financial industry, having worked in mid to large-scale cross-functional projects and/or programs, particularly in lending (consumer and/or loan lending products, such as cash loan, buy now pay later, merchant financing, vehicle financing, etc)</li><li>Well-versed in speaking &amp; writing in English, Bahasa Indonesia; Mandarin is a plus</li><li>Comfortable in fronting conversations with senior leaders and C-suite leaders</li><li>Able to work under pressure with strict implementation timelines</li><li>Possess a strong ability to analyze data and generate insights to value-add to the projects/programs</li><div><b>Soft Skills</b></div><li>Stakeholder management skills</li><li>Sharp business acumen</li><li>Attention to details</li><li>Time management</li><div><b>Hard Skills</b></div><li>Project / ProgramManagement Skills, ideally CAPM certified will be advantageous</li><li>Six Sigma Skills, ideally Six Sigma GreenBeltcertified will be advantageous</li><li>Knowledgeable about financial industry laws &amp; regulations &amp; being compliant at all times</li><li>Good working knowledge of Project Management tools like Jira, Lark and Google Suites</li><li>Knowledge about e-commerce / transport industries is a plus</li>"}],"text":"Program Manager, Consumer Lending - #10310","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">We are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.</span></div>","descriptionBodyPlain":"About The Role\nWe are looking for a dynamic professional to co-lead and support programs consisting of large-scale, high-impact projects and business initiatives, ensuring alignment with scope, budget, schedule, quality, risk, and compliance targets to achieve business outcomes. The ideal candidate will be involved in all aspects of the project and program lifecycle, including initiation, planning, execution, monitoring, and closure. Responsibilities include facilitating day-to-day project and program cadences, preparing materials for management update meetings, driving alignment, and documenting minutes of meetings for follow-up and closure. Additionally, the role requires ensuring project and program governance by maintaining well-documented and archived records to meet audit requirements. As a change agent in Lending, the candidate will propose new ways of working to enhance operational efficiency, business effectiveness, and team collaboration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8","applyUrl":"https://jobs.lever.co/GoToGroup/92f4b266-849a-42f2-b7e0-859360a003d8/apply"},{"additionalPlain":"About the Team\nOur KYC team, a subsidiary of the Payment Platform Team, consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Product, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers. \nWe are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><span style=\"font-size: 16px\">Our KYC team, a subsidiary of the Payment Platform Team, consists of a whole village to create a proper KYC and KYB process from Data Science, Engineers, Product, etc based in Jakarta. Working alongside the Legal, and Compliance Team, we are predominantly concerned with adhering to the robust EDD and CDD while maintaining good service and SLA to our customers.&nbsp;</span></div><div><span style=\"font-size: 16px\">We are a tight-knit group made up of free thinkers, Marvel fans, sports enthusiasts, and wannabe bakers. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"OneKYC","allLocations":["Jakarta"]},"createdAt":1722254311646,"descriptionPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n","description":"<div><span style=\"font-size: 16px\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div>","id":"22a1f73e-1fed-464e-a66c-72139d289c14","lists":[{"text":"What You Will Do","content":"<li>Closely liaise with Ops team to address pain point and issues in the ops process or issues that might triggered customer complaints, and come up with solution to address the issue and oversee the implementation and measure result</li><li>Together with Product &amp; Compliance team, refine all the existing processes to achieve company goals and ensure that user journey complies with country regulations at all times</li><li>Initiate a process review and benchmark to come up with solutions on how best to create a seamless KYC and KYB process to onboard “good user”</li><li>Continuous cost and benefit analysis on the whole KYC and KYB process from Ops and Business perspective including but not limited to when leading projects or in day to day BAU&nbsp;</li><li>Work closely with the Fraud team to identify trends of fraud patterns during KYC and KYB submission, figure out solutions to address the issue, collaborate with the product team in delivering the solution from testing to production deployment, from UAT to sanity testing&nbsp;</li><li>Work closely with Product team to do the continuous review and refine User Interface and User Experience flow throughout the whole KYC and KYB process&nbsp;</li><li>Drive all the initiatives and discussions related to KYC and KYB process including but not limited to, new projects, impact, issue and target by closely collaborating with internal and external counterpart&nbsp;</li><li>Lead the initiative for complaint handling related KYC and KYB process not only related to newly implemented process but also to address issue that might happen from incorrect ops process</li><li>Lead eKYC solution with external clients from start to finish and continue with maintaining the relationship with external clients to ensure a seamless integration and create a seamless user journey.&nbsp;</li>"},{"text":"What You Will Need","content":"<li>A relevant Bachelor or Master Degree such as Business Administration, Management, Computer Science, etc. and PMP or PMI certification is a plus</li><li>Minimum of 5 years of experience as a Project Manager and have a background in leading big scale, multiple projects and process improvement with tangible result</li><li>Should have a working experience in a financial institution is a plus</li><li>Strong sense of operational risk and regulatory risk&nbsp;</li><li>Team player (adaptable, communicative, strategic, collaborative)</li><li>Analytical mindset (able to understand the context, find the correlation between topic, and draw the conclusion)</li><li>Problem-solving (able to link the information’s to solve the problem)</li><li>Experience in creating BRD with the minimum point of problem statement, solution to implemented, cost and benefit analysis and impact analysis&nbsp;</li><li>Proficiency in English both active and passive is a must</li>"}],"text":"Project Manager - OneKYC","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\">They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis</span></div>","descriptionBodyPlain":"They say no man is an island, and this notion holds particularly true for this role. As our Strategic Project Lead, you’ll be an instrumental cog in the verifications wheel of GoTo Financial that directly impacts the company’s ability to ensure its adherence to implementing a robust Enhanced Due Diligence (EDD) and Customer Due Diligence (CDD) in compliance to regulation. You will be in the driver seat to translate company goals into initiatives with tangible result by doing cost and benefit analysis\n","hostedUrl":"https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14","applyUrl":"https://jobs.lever.co/GoToGroup/22a1f73e-1fed-464e-a66c-72139d289c14/apply"},{"additionalPlain":"About the Team\n\nOur Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our Gojek Program Management team is based in Jakarta. Our main responsibility is to grow the Gojek Product through extensive insights and strategic projects. As a team, we’re concerned not only with the company's growth but each other’s personal growth and well-being, too; we enjoy bonding over our shared love of food, movies, and sports.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720752364065,"descriptionPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","id":"20554643-fae8-4082-8797-7d5fd44db8b0","lists":[{"text":"What You Will Do","content":"<li>Develop and run complex analysist to support business decision</li><li>Design and develop dashboards to track business and product performance</li><li>Leverage data from dashboards as well as other sources to derive insights as a basis of rationale and recommendations in decision-making processes</li><li>Running a project management for multiple projects at different stages &amp; complexity</li>"},{"text":"What You Will Need","content":"<li>At least 2-3 years of experience in a business analytics or business intelligence role at a tech company</li><li>End-to-end the problem-solving mindset</li><li>Strong communication and project management skills</li><li>Strong proficiency in SQL, Microsoft Excel, and PowerPoint</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"Project Manager - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a motivated Project Manager to join our dynamic team. As a Project Manager, you will be the backbone for different strategic projects under the Gojek Product team. In this role, your main objective is to provide extensive analysis to help leaders make data-driven decisions. You will be collaborating extensively across various departments, you will liaise with business, marketing, engineering, and data teams, as well as coordinate with other product teams. This role offers an excellent opportunity for growth in project and management within Gojek.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0","applyUrl":"https://jobs.lever.co/GoToGroup/20554643-fae8-4082-8797-7d5fd44db8b0/apply"},{"additionalPlain":"About the Team\n\nInsurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance , CrackScreen Insurance , Health Insurance and we create more than 1 Million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721362323598,"descriptionPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","id":"8906c3d0-c77f-4a0a-8f25-8b738515ede3","lists":[{"text":"What You Will Do","content":"<li>Attend daily standup meetings, sprint planning, and backlog reviews</li><li>Communicate project status to internal and external teams promptly</li><li>Analyze and estimate product features from a testing perspective</li><li>Ensure software quality by adopting best practices in software development</li><li>Design, develop, and execute automation scripts using open-source tools</li><li>Identify, record, document, and track bugs thoroughly</li><li>Perform thorough regression testing when bugs are resolved</li><li>Collaborate with product managers to clarify feature requirements and ensure comprehensive test coverage</li>"},{"text":"What You Will Need","content":"<li>At least 3 years of experience in professional testing</li><li>Strong understanding of unit testing concepts and problem-solving using online resources</li><li>Deep knowledge of Manual &amp; Automation test methodologies and principles</li><li>Capability to create testing scenarios/scripts using test management tools</li><li>Experience in Mobile and API Testing in both manual &amp; automation contexts</li><li>Proficiency with automation tools like Jira, Selenium, RestAssured, ​​TestNg using Java (preferably), Postman, Gitlab, Kafka</li><li>Good understanding of logging mechanisms, messaging services, and pipelines</li><li>Experience working with the AGILE process methodology and strong interpersonal communication skills for collaboration with remote teams</li>"}],"text":"QA Engineer - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA Engineer at Insurance Platform, you will be a pivotal member of the Gopay team, responsible for ensuring the highest quality of our Insurance Service experiences. Your role will involve both manual and automation testing, working closely with the product engineering group to implement test strategies. Over the first six months, you will face challenges such as mastering our test automation frameworks, understanding the intricacies of our systems, and driving quality improvements. Your impact will be crucial in delivering a seamless app experience, enhancing the robustness and reliability of our products.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3","applyUrl":"https://jobs.lever.co/GoToGroup/8906c3d0-c77f-4a0a-8f25-8b738515ede3/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717052781419,"descriptionPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","description":"<div><span style=\"font-size: 10.5pt\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","id":"4ba1eea8-feed-4843-be2e-93a21f0eadb1","lists":[{"text":"What Will You Do","content":"<li>Perform exploratory data analysis using SQL and present interesting findings to business stakeholders to drive business and strategic decisions</li><li>Design and analyze experiments to improve service quality and quantity</li><li>Build and maintain self-serve data products such as dashboards (Looker &amp; Tableau) and tables to reduce time to insights</li><div><br></div>"},{"text":"What You Will Need","content":"<li>Should have at least 2-3 years of practical experience in <a href=\"http://SQL.Prior\" class=\"postings-link\">SQL.</a></li><li><a href=\"http://SQL.Prior\" class=\"postings-link\">Prior</a> experience with applied statistics, experimental design is a <a href=\"http://plus.Able\" class=\"postings-link\">plus.</a></li><li><a href=\"http://plus.Able\" class=\"postings-link\">Able</a> to tell a coherent data narrative using visualization tools and able to set best practices in data visualization to convey a product insight through impactful <a href=\"http://graphs.Proven\" class=\"postings-link\">graphs.</a></li><li><a href=\"http://graphs.Proven\" class=\"postings-link\">Proven</a> ability to recognize business needs and ability to communicate with multiple stakeholders including PMs, business and <a href=\"http://operations.Balance\" class=\"postings-link\">operations.</a></li><li><a href=\"http://operations.Balance\" class=\"postings-link\">Balance</a> attention to detail with swift execution.</li><div><br></div>"}],"text":"Region Analytics Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10.5pt;\">If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy &amp; Planning streams.</span></div>","descriptionBodyPlain":"If you’re a data analyst at heart, this role is for you! Because you’ll be mining insights from the ocean of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers, and spend a majority of your time diving deep into some of the most challenging analytical problems in Gojek - including Product Experience, Partnership, Marketing, Strategy & Planning streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1","applyUrl":"https://jobs.lever.co/GoToGroup/4ba1eea8-feed-4843-be2e-93a21f0eadb1/apply"},{"additionalPlain":"About The Team\n\nAs an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">As an Region Operations Manager, he/she will work as a center of excellence for Operations stream in the Regions. He/she will work very intensively and collaborate with HQ Driver Core, other Region Operations Managers across regions as well as Area Operations Managers from each Area. He/she also will work closely with the Analytics team to analyze Operations data to get valuable insight and recommendation for business.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713428751727,"descriptionPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","description":"<div><b style=\"font-size: 10pt\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","id":"0489939a-c571-4d5f-adaa-95ceac8912c5","lists":[{"text":"What You Will Do: ","content":"<li>Responsible for completed orders and profit and loss target achievement</li><li>Provide analytics to support operations team such as Supply Reliability, Fraud rules, Driver’s Engagement etc. at the regional level</li><li>Deploy defined strategies from operations perspective during the process of establishing the new area of service as well as optimizing existing area</li><li>Ensure SOP and legal compliances in the region</li><li>Support Regional Operation Head to oversee all districts and branches operations</li><li>Analyze driver states &amp; measure efficiency of various driver badges to generate more high quality drivers in the region</li><li>Support Regional Operation Head in product changes roll out in the region</li>"},{"text":"What You Will Need:","content":"<li>Having at least 5 years experience in supply chain, preferably at the managerial level and from Multi National Company or similar experience in the Ride Hailing/ On Demand Service Industry</li><li>Strong analytical thinking and problem solving skills using various improvement tools and methods (preferably have prior exposure to SQL)</li><li>Having good understanding about supply and demand planning</li><li>Able to create creative solutions toward operation issues and empower relevant team to execute properly</li><li>Lead team / project as well as persuade stakeholders to ensure speed &amp; quality of project / initiative</li><li>Proficiency in to converse in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Region Operations Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Region Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.</span></div>","descriptionBodyPlain":"About the Role \n\nRegion Operations Manager play a pivotal role in curating and deploying strategies as well as doing analytics at the region and finding local insights to support the overall Operation strategies. He/she will work collaboratively with all Areas to oversee overall operations and ensure strategic implementation including product changes.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5","applyUrl":"https://jobs.lever.co/GoToGroup/0489939a-c571-4d5f-adaa-95ceac8912c5/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718002291914,"descriptionPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","description":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","id":"f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","lists":[{"text":"What You Will Do","content":"<li>Monitor and analyze transactions and user activities to detect suspicious patterns and potential fraud.</li><li>Conduct thorough investigations of suspected fraud cases and recommend control actions.</li><li>Develop and implement strategies to mitigate fraud risks across the platform.</li><li>Collaborate with product, engineering, and operations teams to enhance fraud prevention measures.</li><li>Prepare detailed reports on fraud incidents, including root cause analysis and actionable recommendations.</li><li>Provide regular updates to senior management on fraud trends, risks, and mitigation efforts.</li><li>Stay updated on the latest fraud trends, tools, and best practices to continuously improve detection and prevention strategies.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Finance, Accounting, Business, Computer Science, or a related field.</li><li>2+ years of experience in fraud risk management or a related role.</li><li>Strong analytical and problem-solving skills, with proficiency in data analysis tools (e.g. SQL, Python, Excel) and experience with visualization tools (e.g. Tableau, DataStudio)</li><li>Excellent communication and interpersonal skills.</li><li>Ability to work independently and as part of a team in a fast-paced environment.</li><li>Strong attention to detail and commitment to accuracy.</li><li>Prior experience in the tech industry is a plus.</li>"}],"text":"Risk Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div><div>As a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.</div><div><br></div>","descriptionBodyPlain":"\nAs a Fraud Risk Analyst at Gojek, you will play a critical role in identifying, analyzing, and mitigating fraud risks across our platform. You will work closely with cross-functional teams to develop strategies, implement fraud prevention measures, and ensure the integrity of our services. This position requires a keen eye for detail, strong analytical skills, and a proactive approach to fraud detection and prevention.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb","applyUrl":"https://jobs.lever.co/GoToGroup/f1f0cc2f-86b5-409e-b2ef-cc1d023e3cbb/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710738954272,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"60d37414-287e-4552-a0d0-accf1737d0ce","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>3-4 years of related payment risk experience, preferably on the acquiring side and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business side</li>"}],"text":"Risk Analyst - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk analyst to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce","applyUrl":"https://jobs.lever.co/GoToGroup/60d37414-287e-4552-a0d0-accf1737d0ce/apply"},{"additionalPlain":"In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">In this role, you will get the opportunity to work together with other teams (risk analyst, GTM and Collection) to find the best solutions to our business problems leveraging big data and machine learning tools.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1704856901936,"description":"","descriptionPlain":"","id":"5611e062-e094-4da3-ab1c-75c85cf62194","lists":[{"text":"What You Will Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volumes of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutions, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers&nbsp;</li>"},{"text":"What you will need","content":"<li>3+ years of experience developing ML solutions</li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Risk Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194","applyUrl":"https://jobs.lever.co/GoToGroup/5611e062-e094-4da3-ab1c-75c85cf62194/apply"},{"additionalPlain":"About The Team\n\nThe team is split across 2 locations supporting different business activities that GTF operates in.  Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The team is split across 2 locations supporting different business activities that GTF operates in.&nbsp; Highly dynamic culture, with independent team members - interacting and influencing business and other functional stakeholders to achieve risk KRs</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713334327811,"descriptionPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","id":"a61cda6c-82fd-4daf-aabf-3db91e01684f","lists":[{"text":"What You Will Do","content":"<li>Key fraud analyst to the business teams for the assigned product lines - conducting deep dives and analysis on risk related issues.</li><li>Close monitoring of risk metrics, underlying drivers - and the overall business metrics</li><li>Assess, validate and optimize risk rules - to ensure best outcome of risk/reward and to meet stated risk target metrics</li><li>Develop risk platform solutions that will balance the various requirements from the product lines but yet maintain a holistic view of the customer experience</li>"},{"text":"What You Will Need","content":"<li>5-8 years of related payment risk experience, preferably on the mobile apps and e-wallets</li><li>Able to assess issues and recommend solutions both at the strategic and tactical levels - balancing the business vision and practical implementation considerations.</li><li>Intermediate proficiency in using GSuite and other data skills (SQL, BigQuery etc)</li><li>Proactively builds trust-based relationships with stakeholders while maintaining the ability to remain objective</li><li>Strong understanding of risk solutions, product implementation - on the business sid</li>"}],"text":"Risk Manager - Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.&nbsp; The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.&nbsp;&nbsp;</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for exceptional fraud risk manager to identify potential fraud risk, develop mitigating strategies in our expanding business.  The role holder will be responsible for delivering on target risk metrics - by analyzing data and implementing risk rules and recommending mitigation plans.  \n","hostedUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f","applyUrl":"https://jobs.lever.co/GoToGroup/a61cda6c-82fd-4daf-aabf-3db91e01684f/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1715584452832,"descriptionPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","description":"<div><b style=\"font-size: 16px\">About the team:</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","id":"d6ac496c-e0ad-4669-b594-ede9bf8d55f9","lists":[{"text":"What you will do:","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed,</li><li>Resolve account issues and complaints,</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis,</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments,</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation,</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients,</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms.</li>"},{"text":"What you will need:","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area,</li><li>A minimum of 3 years of experience in business management, sales, or project management is mandatory. </li><li>Prior experience in e-commerce and managing key accounts will be a plus point,</li><li>Fluency in both Bahasa and English is required,Able to multitask, prioritize, and manage time efficiently,</li><li>Ability to negotiate, persuade and influence others,</li><li>Excellent interpersonal, communication, presentation and analytical skills,</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills,</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners.</li>"}],"text":"Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the team:</b></div><div><span style=\"font-size: 16px;\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. </span></div>","descriptionBodyPlain":"About the team:\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9","applyUrl":"https://jobs.lever.co/GoToGroup/d6ac496c-e0ad-4669-b594-ede9bf8d55f9/apply"},{"additionalPlain":"The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood campaigns.\n\nIn the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales team.When our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their efficiency.\n\nIn our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">The Sales Excellence team is an integral part of the Greater Sales Team, and based in HQ Office Jakarta, Indonesia. We work closely with both the Sales Strategy, product, function teams as well as the Sales team in the regions. Our primary focus is to ensure that the company’s KRs are achieved by providing the support to the sales and sales support teams needed to excel in their job, which could vary from solving merchant’s onboarding issues, improving business processes, to supporting GoFood </span><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">campaigns.</span></a></div><div><br></div><div><a href=\"http://campaigns.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> the past, our team has created the automated consolidated performance monitoring dashboard from scratch that became the compass of the sales </span><a href=\"http://team.When\" class=\"postings-link\"><span style=\"font-size: 10pt\">team.When</span></a><span style=\"font-size: 10pt\"> our scope is broadened to include Enterprise sales team, we not only replicate the performance dashboard but also revamped the data structure to make consistent with the rest of the sales team. Going forward, we expect to do more analytical projects that could help guide the sales team and improve their </span><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">efficiency.</span></a></div><div><br></div><div><a href=\"http://efficiency.In\" class=\"postings-link\"><span style=\"font-size: 10pt\">In</span></a><span style=\"font-size: 10pt\"> our spare time, you can find us binge watching all kinds of shows on Netflix (from Documentaries all the way to K Dramas!). On top of that, we are a tight-knit, fun-loving, collaborative and hardworking individuals who enjoy each other's company, especially over good food and good conversation :) (because who doesn’t?)</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"Sales Excellence","allLocations":["Jakarta"]},"createdAt":1714365620212,"descriptionPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","description":"<div><span style=\"font-size: 10pt\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","id":"f39be622-e287-41df-bcb2-7389478a1be4","lists":[{"text":"What you will do","content":"<li>Oversee the performance tracking and monitoring of the whole Enterprise Sales Team</li><li>Ensure that the Enterprise Sales team has all the data they need to achieve their target for all KRs</li><li>Act as a consultant and discuss with the EKAMs on the business needs/challenges that their merchants are facing</li><li>Provide data and data driven insights to EKAMs to help address said challenges</li><li>Assist in performing periodical business analysis, tailored to each merchant based on their business needs</li><li>Assist in the daily tasks and smooth operations of Enterprise Sales Support</li><li>Liaise with HO team for merchant x sales account management, target, tracker, etc</li><li>Liaise with other teams (e.g. BI, Salestech) when there is new KRs / data point that needs to be analysed</li><div><br></div>"},{"text":"What you will need","content":"<li>At least 2 years of relevant experience in data analytics&nbsp;</li><li>Good business acumen, able to develop analysis with good storyline and flow</li><li>Proficient in SQL, Google BigQuery and the reporting thereof is an advantage</li><li>Proficient in handling large amount of data using tools/softwares such as google sheet, metabase and datastudio</li><li>Great communication and understanding skill, able to explain technical terms in simple, understandable manner</li><li>Experienced in working with multiple stakeholders from different backgrounds with good level of empathy</li><li>High interest and eagerness to analyse different parts of businesses to help achieve growth</li><li>Clear understanding of Gojek services and the tech industry</li><div><br></div>"}],"text":"Sales Support Senior Associate, Enterprise","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team </span></div>","descriptionBodyPlain":"As our Enterprise Sales Senior Associate, you will be the brainstorming partner for our Enterprise Key Account Managers (EKAM), collating data, producing insights while helping to formulate the next action steps for the Enterprise merchants so they can devise the best strategy to win the market all the while growing their business even better with us. You will also be working with data completeness, timeliness and accuracy, ensuring data integrity between Enterprise Sales Team and HQ Sales Team \n","hostedUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4","applyUrl":"https://jobs.lever.co/GoToGroup/f39be622-e287-41df-bcb2-7389478a1be4/apply"},{"additionalPlain":"About The Team\n\nOur Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Savings team is a small family based in Jakarta, Indonesia. We are a tight-knit group who are bonded by two things: our genuine desire to add value to the lives of our consumers, and the growth mindset and passion to make an impact. Our team enjoys what we do since we get to see the impact of our work reflected in our consumer's everyday lives. Our team has launched GoPay Tabungan by Jago, the first of its kind to combine the simplicity of e-money with the benefits of a bank. The business has grown rapidly since then and has reached out to millions of users. This is just the beginning of the journey, and we want you to embark on this journey with us! Come join our family to see what we mean!</div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1720004794044,"descriptionPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","description":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","id":"bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","lists":[{"text":"What You Will Do","content":"<li>Identify areas of business growth by structuring problem statements and forming hypotheses</li><li>Query and process large amounts &amp; complex data sets of our customers’ behavior, usage patterns, statistical trends, and funnel performance&nbsp;&nbsp;</li><li>Synthesize actionable insights and solutions from the data analysis</li><li>Own and drive the proposed initiatives to achieve business objectives</li><li>Visualize and communicate findings in an easy-to-understand, concise, and clear format</li><li>Experiment with the growth initiatives and continuously iterate to find areas for improvements</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience working in a data-driven environment, previous experience in the tech industry is a bonus</li><li>Proficient in data query, data processing, and charting to synthesize actionable insights from large sets of complex data</li><li>Strong structured problem-solving abilities to identify issues, form hypotheses, and generate recommendations</li><li>Ability to create and execute experimentation plans or A/B testing on key growth initiatives&nbsp;</li><li>Excellent project and stakeholder management skills to ensure all planned initiatives are met on high quality and on time</li><li>Excellent written &amp; verbal communication skills focused on improving collaboration, understanding, and information exchange across all stakeholders</li><li>Ability to learn new things and adapt your priorities quickly within a fast-paced environment</li>"}],"text":"Savings Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>As Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.</div><div><br></div><div>You’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.</div>","descriptionBodyPlain":"About The Role\n\nAs Savings Growth Lead, you will be an integral member of the GoPay Consumer Payments team. Your primary responsibilities are 1) translating complex data into actionable insights, 2) structuring problems and identifying hypotheses, and 3) proposing initiatives and improvement plans for the business and product. In addition, you will work closely with our strategic bank partner, Bank Jago, to embed banking solutions in people’s daily lives.\n\nYou’ll be presented with a unique opportunity to spearhead strategic initiatives, take ownership of the new initiatives you’ll enact, and impact millions of our consumer's financial well-being.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62","applyUrl":"https://jobs.lever.co/GoToGroup/bf41d2c6-91b0-4c83-a145-dfcb3ee24b62/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1698657930091,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"376aefd9-6d6c-4e57-8040-a3b0dd416d26","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2 to 4 years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26","applyUrl":"https://jobs.lever.co/GoToGroup/376aefd9-6d6c-4e57-8040-a3b0dd416d26/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719471574933,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>2-4+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9","applyUrl":"https://jobs.lever.co/GoToGroup/d19a612f-4737-4a87-b7c2-ee2e29ef0cf9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Consumer Experience","allLocations":["Bengaluru"]},"createdAt":1716277072995,"descriptionPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"0169bd4d-f352-4162-8e8e-2c09df5b8db4","lists":[{"text":"What Will You Do","content":"<li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion;</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner from a testing point of view;</li><li>Build, contribute, and maintain automated test suites and frameworks on Apps and API utilizing Java/JavaScript or similar.</li><li>Ability to understand product feature requirements and test them effectively.</li><li>Ability to work on Functional, automation testing for Web, APIs, and mobile apps both Android and iOS.</li><li>Work with Business, Product, and Dev teams in close coordination.</li><li>Well-versed with Agile methodology, SDLC, and STLC.</li>"},{"text":"What You Will Need","content":"<li>Preferably 2-5 years of experience in professional testing in /API/Web using RestAssured with Java, Appium (Android &amp; iOS) Selenium, or similar frameworks where the experience in service virtualization / WebServices-API testing through POSTMAN or any similar tool.</li><li>Basic knowledge of Java, test Parallelisation (API and App), cross-browser coverage, Selenium with Java, and Reporting Plugins i.e. Allure, and Extent.</li><li>Hands-on experience with Rest Assured, Selenium/Appium, IntelliJ, and TestNG or similar frameworks.</li><li>Agile / Scrum / Kanban experience Soft Skills and ability to work and communicate with cross-functional teams.</li><li>Experience in CI/CT using Jenkins or similar continuous integration, release, and change management tools i.e. GIT or similar GitLab.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"SDET - Growth","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">As a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role\n\nAs a QA engineer —you would need to be able to execute and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4","applyUrl":"https://jobs.lever.co/GoToGroup/0169bd4d-f352-4162-8e8e-2c09df5b8db4/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Security and System Infra Manager (CISSP) role will be reporting directly to the VP of Technology of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788743352,"descriptionPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","id":"08aa1472-d91f-4c5d-b5e0-e88163943bcd","lists":[{"text":"What You Will Do","content":"<li>Design, implement, and maintain the company’s IT infrastructure, ensuring scalability, reliability, and performance.</li><li>Manage servers, networks, databases, and cloud services to support business operations and growth.</li><li>Develop and implement comprehensive cybersecurity strategies to protect the company’s assets and data.</li><li>Conduct regular security assessments, vulnerability scans, and penetration testing to identify and mitigate risks.</li><li>Oversee the installation, configuration, and maintenance of hardware and software systems.</li><li>Ensure data integrity and availability through effective backup and disaster recovery planning.</li><li>Develop and enforce IT policies and procedures to ensure security, compliance, and efficient operations.</li><li>Ensure compliance with relevant regulations and industry standards.</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, Information Technology, or a related field. A Master’s degree or relevant certifications (e.g., CISSP, CISM) is a plus.</li><li>Minimum of 7 years of experience in IT infrastructure management, cybersecurity, or a related role, with at least 3 years in a leadership position, preferably in the cryptocurrency or fintech industry.</li><li>Strong understanding of IT infrastructure, network administration, and cybersecurity practices.</li><li>Proven track record of developing and implementing successful IT and security strategies.</li><li>Excellent analytical, problem-solving, and organizational skills.</li><li>Strong leadership, communication, and interpersonal skills.</li><li>Preference qualifications in high-frequency trading</li>"}],"text":"Security and System Infra Manager (CISSP) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced and highly skilled Security and System Infrastructure Manager to join our cryptocurrency company in Jakarta. The Security and System Infrastructure Manager will be responsible for overseeing the company’s IT infrastructure, ensuring robust security measures, and maintaining the integrity and availability of all technological resources. This role requires a deep understanding of IT infrastructure, cybersecurity practices, and the unique challenges associated with the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd","applyUrl":"https://jobs.lever.co/GoToGroup/08aa1472-d91f-4c5d-b5e0-e88163943bcd/apply"},{"additionalPlain":"About the Team\n\nThe Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Security Architecture is primarily responsible for ensuring the security controls are being considered by the Engineering teams right from the beginning of product/application development. This will help in reducing the attack surface and also significantly reduce the cost to mitigate any security issue that got detected during the later stages of application development. The security architecture team members will also get exposure to various technologies being used by the Engineering teams and develop necessary security standards/best practices. This will help the security architecture team members to be updated and relevant with various technologies.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial <a href=\"http://platforms.It\" class=\"postings-link\">platforms.It</a> is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719832381686,"descriptionPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","id":"9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","lists":[{"text":"What You Will Do","content":"<li>Perform security design on applications (web, mobile) and infrastructures (cloud, on-premise)</li><li>Perform security code review (manual, automated) on applications and infrastructures</li><li>Ensure applications and infrastructures are secure by design, follow secure design principles, and adopt secure coding practices</li><li>Identify security gaps and vulnerabilities, and propose appropriate controls and remediations</li><li>Propose solutions to wide-ranging security problems</li><li>Raise security awareness among the Product, Engineering, and Infrastructure team by conducting security training, and having regular security discussions</li><li>Bridge communication between the broader Information Security team with the Product, Engineering, and Infrastructure team</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Computer Science, or a related field</li><li>Minimum 3 years of experience in Software Engineering, preferably on web and mobile application</li><li>Minimum 3 years of experience in Information Security, preferably in application and cloud security</li><li>Good knowledge of common secure design principles and secure coding practices</li><li>Good knowledge of common adversarial techniques, tactics, and procedures&nbsp;</li><li>Ability to learn new things quickly and independently</li><li>Ability to communicate effectively, preferably in English</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Security Engineering Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">The Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">As Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.</span></div>","descriptionBodyPlain":"About the Role\n\nThe Security Architecture team is responsible for security products and services used by millions of users every day. The team conducts security design and code reviews on applications (web, mobile) and infrastructures (cloud, on-premise). The team works closely with the Product, Engineering, and Infrastructure teams throughout the Software Development Life Cycle.\n\nAs Security Engineering Lead, you will lead security initiatives on critical projects. You are required to review large and complex systems, identify security gaps and vulnerabilities, and propose adequate security controls. You are expected to solve difficult security challenges by balancing security and usability.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12","applyUrl":"https://jobs.lever.co/GoToGroup/9a7a6e83-9532-48a6-b1b1-b7a1350b4f12/apply"},{"additionalPlain":"About the Team\n\nThe Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.\n\nCTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Cyber Threat Intelligence (CTI) Team supports GoTo’s business and security functions decision-making, to help reduce the effectiveness of cyber threats before they attack or while they are attacking.</div><div><br></div><div>CTI Analysts are like the CIA of the organization, they hear, know, and see everything. They are instrumental in strategic decision-making on the cyber battlefield. With their razor-sharp analysis, they can make a game-changing impact in terms of ensuring the cyber security of GoTo’s employees and customers.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CISO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721369663762,"descriptionPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","id":"767d8980-5402-488d-b62c-222c0b4a0bfc","lists":[{"text":"What You Will Do","content":"<li><b>Observe</b>: Monitor the surface, deep, darkweb, and listen to your intelligence-sharing circles.</li><li><b>Analyze</b>: Through understanding of the internal landscape assess the (predicted threat). Support the incident response investigation, when needed.</li><li><b>Disrupt</b>: disrupt the effectiveness of the threats by various means.</li><li><b>Report</b>: Communicate timely, simply, and effectively the threat and key recommendations.</li>"},{"text":"What You Will Need","content":"<li>Strong technical foundation in IT, Networking, and Cyber Security.</li><li>Working experience with one or multiple categories of tools (open source or commercial): Link Analysis Tools, Threat Modeling Tools, (Threat) Feed Aggregators, Threat Intelligence Platforms (TIP’s), Digital Risk Protection platforms, Malware Sandboxes, SOAR, SIEM or EDR.</li><li>5-7 Years of working experience (strong mid-level or senior in cyber security), relevant degree (bachelor or higher), or reputable industry certification (e.g.: ISC2, GIAC, Offsec, EC Council) preferred.</li><li>Extensive working experience in the CTI field is preferred, candidates from the following affiliated fields are alternatively also preferred: SOC, Vulnerability Management (VAPT), Penetration Testing, or Digital Forensics Incident Response (DFIR).</li><li>Possess critical thinking and problem-solving skills.</li><li>Leadership, experience in mentoring junior members, and stakeholder management skills are a must. You will be leading multiple important initiatives across the teams/companies.</li><li>Proficiency in English and Indonesian, both in written and oral form.</li><li>Outstanding reporting skills: content, delivery, clarity, brevity, and presentation.</li>"}],"text":"Senior Cyber Threat Intelligence Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10.5pt;\">You are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.</span></div>","descriptionBodyPlain":"About the Role\n\nYou are responsible for looking out on the external threat landscape and supporting ongoing investigations using a wide variety of open, commercial, and private intelligence sources and converting these to actionable, timely, accurate, and objective Cyber Threat Intelligence (CTI) reports that take the context of the intelligence consumer strongly into consideration.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc","applyUrl":"https://jobs.lever.co/GoToGroup/767d8980-5402-488d-b62c-222c0b4a0bfc/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1719213882004,"descriptionPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","description":"<div><b style=\"font-size: 10pt\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","id":"1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","lists":[{"text":"What you will do","content":"<li><b>Design, build, and maintain the ETL </b>from various sources into the data mart; Troubleshoot and resolve data-related issues, including data discrepancies, anomalies, and performance bottlenecks</li><li>End to end data project ownership and collaboration with cross-functional teams to understand data requirements and design data models that support the organization's single version of truth</li><li>Ensure the quality, accuracy, and reliability of our data by implementing data validation checks and error handling mechanisms</li><li>Develop and customize Tableau/Google Sheet/Looker studio reports that provide actionable insights to stakeholders</li><li>Create and maintain documentation related to data structures, processes, and transformations for future reference</li>"},{"text":"What you will need","content":"<li>4 years of experience in <b>Data Analyst/BI Analyst/</b>BI Engineer</li><li>Advance knowledge of <b>SQL </b>and Python</li><li>Able to lead a small team also can work as a individual contributor</li><li>Hands on experience with data visualization Tableau Looker studio/Google Sheet</li><li>Strong analytical and problem-solving skills, with keen attention to detail</li><li>Excellent communication skills (English is a must) to collaborate with technical and non-technical stakeholders</li><li>Having a people manager experience is a plus</li>"}],"text":"Senior Data Analyst (Analytics Engineer)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 10pt;\">About the team </b></div><div><br></div><div><span style=\"font-size: 10pt;\">Financial services platform is Gojek’s financial services arm, working to provide responsible &amp; sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">Our Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.</span></div>","descriptionBodyPlain":"About the team \n\nFinancial services platform is Gojek’s financial services arm, working to provide responsible & sustainable financial services to Gojek's three main segments: consumers, merchant-partners, and driver-partners. Our team operates with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term. With our \"user first\" mindset, we aim to transform the financial services sector in Southeast Asia, starting with Indonesia.\n\nOur Data team, a financial data services sub-pod, is an established family with members stationed across Jakarta, India, Beijing and Singapore. We’re in charge of running hundreds of instances and deployments across all of our payment products, directly impacting millions of users every single day. Most recently, our team has built products that reduce the overall time to model, curate, and access data, streamlining our efficiency and internal processes significantly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b","applyUrl":"https://jobs.lever.co/GoToGroup/1e85c9c1-50ed-4334-97d1-91eba3b6ef5b/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"HoldCo - COO Office","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716264696268,"descriptionPlain":"\n","description":"<div><br></div>","id":"6d8ebb73-2348-423d-847e-b8a8408ac1ed","lists":[{"text":"What You Will Do","content":"<li>Gather business requirements to support BI projects.</li><li>Explore existing and new data sources and facilitate the integration to the Data Warehouse.</li><li>Design and develop Data Quality Framework across Data Platform.</li><li>Design, implement Data Model for enterprise data warehouse.</li><li>Classifying data based Data Governance policy and Data Access Framework.</li><li>Develop data definition and metrics and maintain the consistency across Data team.</li><li>Modify existing structured and unstructured data integration solutions for rapidly evolving business needs.</li><li>Collaborate with a cross-functional team to resolve data quality and operational issues.</li><li>Create conceptual models and data flow diagrams.</li><li>Participate with end users to gather requirements and consult on data integration solutions.</li><li>Receive and adhere to project delivery deadlines.&nbsp;&nbsp;</li><li>Migrate code across environments and leverage a source code management system.</li><li>Develop and maintain proper documentation for data pipeline and service.</li>"},{"text":"What you will need ","content":"<li>Bachelor's or Master's degree in Computer Science, Engineering, Information Systems, or related fields.</li><li>2-5 years of experience in data engineering, software engineering, or a similar role.</li><li>Proficiency in programming languages such as Python, Java, or Scala.</li><li>Solid understanding of SQL, database management systems, and data modeling concepts.</li><li>Experience with big data technologies such as Hadoop, Spark, or Kafka.</li><li>Hands-on experience with cloud platforms such as AWS, Azure, or Google Cloud Platform.</li><li>Strong problem-solving skills and attention to detail.</li><li>Ability to design and implement scalable data pipelines and ETL processes.</li><li>Excellent communication and collaboration skills to work effectively with cross-functional teams.</li><li>Deeper understanding of data engineering concept, programming language, and big data technology.</li>"}],"text":"Senior Data Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed","applyUrl":"https://jobs.lever.co/GoToGroup/6d8ebb73-2348-423d-847e-b8a8408ac1ed/apply"},{"additionalPlain":"Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1719472943608,"descriptionPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","description":"<div><span style=\"font-size: 10pt\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","id":"90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","lists":[{"text":"What You Will Do","content":"<li>Design, build, and maintain data streaming solutions.</li><li>Troubleshoot and resolve data-related issues, including discrepancies, anomalies, and performance bottlenecks.</li><li>Ensure scalability and reliability of the data streaming platform.</li><li>Collaborate with data engineers, data scientists, and other stakeholders to understand requirements and provide tailored streaming solutions.</li><li>Monitor and optimise performance to ensure low latency and high throughput.</li><li>Perform regular maintenance tasks, including upgrades and patches.</li><li>Document design, implementation, and maintenance processes.</li><li>Stay updated with the latest advancements in data streaming technologies.</li>"},{"text":"What You Will Need","content":"<li>3 - 6 years of experience as a Data Engineer.</li><li>Strong programming skills in Java.</li><li>Hands-on experience in real-time streaming with Apache Flink.</li><li>Experience working with Apache Kafka and Kubernetes.</li><li>Experience working with any cloud platform and NoSQL database.</li><li>Strong analytical and problem-solving skills, with keen attention to detail.</li><li>Excellent communication skills for collaborating with technical and non-technical stakeholders.</li><li><b>Good to have: </b>Programming in Go/Python, IAC using Terraform, Batching ETL and exposure to open data lakehouse architecture is a plus</li><li><br></li>"}],"text":"Senior Data Engineer - Data Streaming","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.</span></div>","descriptionBodyPlain":"As a Data Engineer, you’ll be a crucial member of the GTF Data Platform team at Gojek. In this role, you’ll take the wheel in building and managing our real-time streaming solutions, enabling and delivering reliable and trustworthy real-time data that affects our GTF products. Your responsibilities include designing, developing, and maintaining our data streaming solutions while adhering to our data governance policies and best practices. On this ride, you'll be accompanied by engineers, members of the DWH team, and data scientists.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b","applyUrl":"https://jobs.lever.co/GoToGroup/90ae6b8f-f09c-4ae9-ae10-4d396a4e373b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720774001435,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"976d0171-5a06-43e2-9ec6-e0b45345c6fd","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd","applyUrl":"https://jobs.lever.co/GoToGroup/976d0171-5a06-43e2-9ec6-e0b45345c6fd/apply"},{"additionalPlain":"About The Team\nThe GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><span style=\"font-size: 10pt\">The GTF Data Science team builds critical data science/ML models to make GoPay a safe, trusted and fun way to do payments. Our team members come from diverse backgrounds, and use mathematics, statistics, machine learning, deep learning to solve some of the toughest business problems in GoPay. We are passionate about data science, innovation, and their impacts to the business</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1684915963454,"descriptionPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","description":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","id":"a539cdc1-109f-48e8-9b24-1a831b735f01","lists":[{"text":"What Will You Do","content":"<li>Combine technical and business knowledge to develop innovative data science solutions</li><li>Rapidly prototype solutions and contribute to product and feature discussions</li><li>Analyze large volume of data and generate actionable insights</li><li>Experiment with different ML techniques and research the latest technologies (e.g. LLM) to determine the best approach</li><li>Own end-to-end solutioning, from formulating the technical problem to deployment of the solution as part of a cross-functional team of scientists, analysts, product managers, and engineers</li>"},{"text":"What You Will Need","content":"<li>6+ years of experience developing ML solutions, 2-3 years of <b>fraud risk experience in account takeover, scam, and abuse</b></li><li>Strong quantitative and problem-solving skills</li><li>Solid understanding of Statistics/ML fundamentals and experience in Python, R</li><li>Communication skills to engage with business stakeholders to understand their needs and effectively communicate the results of the analytical solutions</li><li>Ability to write clear and concise technical documentation</li><li>Ph.D. or Masters in a quantitative discipline (good to have - Experienced - Bachelor)</li>"}],"text":"Senior Data Scientist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><span style=\"font-size: 10pt;\">As a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.</span></div>","descriptionBodyPlain":"About the Role\nAs a senior data scientist in the GTF Risk Data team, you will develop data science models to protect GoPay and its customers. You will have the opportunity to work with large-scale data to derive new intelligence and use cutting-edge data science techniques. You will partner with Risk, product, and engineering stakeholders to identify and solve some of the most impactful and stimulating business problems in the payments space. You will work in a fast-paced environment with direct impacts to the business.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01","applyUrl":"https://jobs.lever.co/GoToGroup/a539cdc1-109f-48e8-9b24-1a831b735f01/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Platform Mobility, Care & Comms","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1713852044349,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"34f6146a-c482-407c-a31c-72ac9bb90a7c","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>Analyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist - Marketplace (Singapore)","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c","applyUrl":"https://jobs.lever.co/GoToGroup/34f6146a-c482-407c-a31c-72ac9bb90a7c/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1705993404249,"descriptionPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","description":"<div><span style=\"font-size: 10pt\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","id":"86673189-b5e2-4ace-b1a3-5ab20f14d84d","lists":[{"text":"What You Will Do","content":"<li>Understand business concerns and formulate them as technical problems that can be solved using data and math/stats/ML</li><li>Work with Product managers, Machine Learning Engineers, and Business Users to build, deploy, and scale Data Science solutions on Driver Experience and Earning related initiatives at Gojek that impact the driver’s livelihood</li><li>Use your experience in Data Science, Machine Learning, Software Engineering, distributed systems to rapidly prototype and deploy the systems to production</li><li>Work with Business teams to continuously refine, improve the systems to cater to ever-changing Gojek need</li><li>sAnalyze large volume data and generate insights that will be actionable</li><li>Design and conduct experiments to measure the impact of ML solutions or product features launched by Gojek Marketplace Team (Pricing and Matchmaking) </li>"},{"text":"What You Will Need","content":"<li>Bachelor's/Master’s Degree in Computer Science, Statistics, Operation research or other quantitative fields, with 3-5 years of relevant experience</li><li>Hands-on experience in Statistics/ML fundamentals and demonstrated experience in <b>Python</b>, SQL, and basic visualization tools</li><li>Solid knowledge of Data Science and Machine Learning fundamentals, with proven experience to formulate Data Science solutions to business problems</li><li>Ability to write clear and concise technical documentation</li><li>Experience in taking Data Science models to production&nbsp;</li><li>Expertise to conduct analysis independently for a business problem through data manipulation, formulation of hypotheses, design and statistical analysis of experiments to test them</li>"},{"text":"Knowing the Following Would be a Bonus","content":"<li>Preferably, has domain experience in Machine Learning Engineering&nbsp;</li><li>Experience in Operation Research&nbsp;Experience in remote development using cloud platforms (GCS, AWS, Azure) and data processing frameworks/ schedulers (Flink, Airflow)&nbsp;</li><li>Experience in software engineering workflow (version control using Git, CI/CD)</li><li>Prior experience with dbt is a plus</li>"}],"text":"Senior Data Scientist (India)","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.</span></div>","descriptionBodyPlain":"If you’re a data scientist at heart, this role is for you! because you’ll be mining insights from the sea of data, building data products, and designing experiments with the ability to see the real-time impact of your contribution. You’ll get to work with a talented troop of business leads, product managers and fellow data folks, and spend a majority of your time diving deep into some of the most challenging analytical problems in the Gojek Marketplace - the brain that powers all of Gojek’s services - including Matchmaking, and Pricing streams.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d","applyUrl":"https://jobs.lever.co/GoToGroup/86673189-b5e2-4ace-b1a3-5ab20f14d84d/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1707210044551,"descriptionPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","description":"<div><span style=\"font-size: 10pt\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","id":"c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","lists":[{"text":"What You Will Do","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What You Will Need","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li>"}],"text":"Senior Data Warehouse Engineer","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment.</span></div>","descriptionBodyPlain":"Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69","applyUrl":"https://jobs.lever.co/GoToGroup/c61882d6-edcf-4b1f-bda3-8b3c5e3c3a69/apply"},{"additionalPlain":"About The Team\n\nOur Data Warehouse team is based in Jakarta & Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nOur team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our Data Warehouse team is based in Jakarta &amp; Bangalore. Working alongside stakeholders, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our team works hard but plays hard, too. We mean the latter in a literal sense, because we're a team full of musicians! We have 2 pianists, 1 guitarist, 1 drummer, more than 2 male singers, 1 female singer, 1 Rockstar, and 1 dangdut singer (yes, you read it right ). So, you best believe that we have several karaoke nights together! Even if you aren't musically inclined, no fear. We love bonding over card games (Werewolf is a team favorite), and even hosting mini talent shows for our own entertainment. Join us and show your hidden skills!</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1713498805305,"descriptionPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","description":"<div><span style=\"font-size: 10pt\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","id":"2b430ba4-210e-4db6-a63e-c11459a0304f","lists":[{"text":"What Will You Do?","content":"<li>Handle end-to-end data pipelines from heterogeneous input and output for analytical purposes</li><li>Become data architect by implementing appropriate data modeling concepts depending on data type and use cases</li><li>Responsible for managing a single version of truth and turning data into critical information and knowledge that can be used to make sound business decisions</li><li>Define clear and well-scoped requirements documents, including specs and workflows, that are easily understood by technical and non-technical audiences</li><li>Work with data stakeholders (Product Managers, Product/Business Analysts and Product Engineers) to ship data warehouse features and data product improvements</li><li>Contribute to the product strategy and execute on the prioritized roadmap</li><li>Mentoring &amp; develop junior team members in the team</li>"},{"text":"What Do You Need? ","content":"<li>Have at least 4 years experience in data environment as Data Warehouse Developer</li><li>Advanced in SQL and data warehouse concepts</li><li>Advanced in more than one programming language, especially Python or Go or Java</li><li>Have experiences working with batch / real-time data processing, data modeling concepts, and implementation</li><li>Have experiences working in GCP data environment such as GCS &amp; Bigquery</li><li>Analytical and data-driven, you love digging into the data to understand what’s happening and define &amp; measure success on every project</li><li>Good communication &amp; interpersonal skills</li><li>You’re passionate about your customers and always bring questions back to what will serve them best</li>"}],"text":"Senior Data Warehouse Engineer - India","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations &amp; service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing &amp; maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, &amp; data engineering in a large scale environment. </span></div><div><br></div><div><span style=\"font-size: 10pt;\">Growth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey &amp; it will be good for your career growth forward.</span></div>","descriptionBodyPlain":"Gojek is a data driven organization. Data has become the most critical part for Gojek to become the market leader through innovations & service excellences. As a Data Warehouse Developer, you’ll take a critical part in developing & maintaining our large scale data environments that will be valuable for our main users to generate business insights, decision making, deep analysis, even data science products. You’ll have the opportunity to work with multiple cross functional teams, such as Product Managers, BI Analyst, Product Engineers, Finance, Marketer, IT Security, etc. You’ll also have the opportunity to flex your Data Warehouse core skills, such as SQL, data modeling, data architecture, data governance, & data engineering in a large scale environment. \n\nGrowth mindset is one of our core values. We’ll make sure that you’ll learn a lot in this journey & it will be good for your career growth forward.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f","applyUrl":"https://jobs.lever.co/GoToGroup/2b430ba4-210e-4db6-a63e-c11459a0304f/apply"},{"additionalPlain":"About the Team\n\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719199384298,"descriptionPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"905d4e32-1699-4fcc-96b3-aa6aa0b462cb","lists":[{"text":"What You Will Do","content":"<li>Analyze database performance data to identify bottlenecks and implement optimizations to enhance system efficiency and reliability</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li><li>Design and develop custom tools and utilities to facilitate various database operations, leveraging programming languages such as Ruby, or Golang</li><li>Ensure database security best practices are implemented and maintained, including access control, encryption, and compliance with relevant regulations</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Continuously evaluate database infrastructure usage and performance metrics to identify opportunities for cost optimization</li><li>Benchmarking tests to evaluate the impact of configuration changes on database performance. This helps in identifying optimal parameter values and fine-tuning configurations for different types of workloads.</li><li>Tuning database configuration parameters to optimize database performance for the application</li>"},{"text":"What You Will Need","content":"<li>8+ years experience as a DBA Engineer in managing databases for a large production environment</li><li>Expert in various database management systems (MySQL/PostgreSQL, Redis, MongoDB, and Elastic Search), and techniques for optimizing databases and understanding the basic cloud platform (AWS or GCP)</li><li>Advanced skills in a programming language like Ruby or Golang, and possess deep expertise in shell scripting</li><li>Excellent experience with Linux is required and expertise in server configuration, maintenance, and troubleshooting</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)</li><li>Proficient in seamlessly conducting database upgrades, ensuring uninterrupted operations and system integrity.</li><li>Proficiency in configuring and utilizing monitoring and diagnostic tools to pinpoint and address database performance issues effectively</li><li>In-depth knowledge of the various configuration parameters tailored to the specific database management system</li>"}],"text":"Senior Database Administrator Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Lead DBA Engineer position, specifically with expertise in design, administration, high availability, and operational support experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Lead DBA Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, redis, etc that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb","applyUrl":"https://jobs.lever.co/GoToGroup/905d4e32-1699-4fcc-96b3-aa6aa0b462cb/apply"},{"additionalPlain":"About the Team\nWe are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div>We are a team dedicated to maintaining crucial database platforms and incorporating new database technologies and systems into the Gojek ecosystem. Working under the DBaaS (Database as a Service) team at a company like Gojek is an exciting and dynamic experience. The team is at the forefront of integrating cutting-edge database technologies to support Gojek's vast and complex ecosystem. You'll collaborate with diverse teams, ensuring that the databases are robust, scalable, and highly reliable, directly impacting millions of users. The fast-paced environment fosters continuous learning and professional growth, with ample opportunities to tackle challenging problems and implement innovative solutions. Gojek's collaborative culture ensures a supportive and inclusive atmosphere, making it an ideal place for those passionate about database technologies to thrive and contribute significantly to the company's success.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics, and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms. It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing most of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics, and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchant solutions. Its consumer services include GoPay and GoPayLater and serves businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, and Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your due diligence to prevent being victims of fake job scams if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Gurugram","team":"-","allLocations":["Gurugram"]},"createdAt":1719198420770,"descriptionPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","description":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","id":"28fe323b-ed5f-482b-b71d-ed60662bed8b","lists":[{"text":"What You Will Do","content":"<li>Develop automation scripts and tools for provisioning, deployment, monitoring, and backup/recovery of databases using infrastructure as code (IaC) principles</li><li>Implement robust monitoring and alerting systems for database performance metrics&nbsp;</li><li>Develop and maintain disaster recovery plans and backup strategies for databases to minimize downtime and data loss in the event of failures</li><li>Maintain version-controlled configurations for database servers, ensuring consistency and repeatability across environments via IaC</li><li>Automate routine tasks such as database backups, schema migrations, and data archiving to improve operational efficiency</li><li>Develop database high availability and replication solutions to meet the requirements of critical applications.</li><li>Develop standardized operational procedures within the DBaaS framework to ensure the consistent provision of highly available solutions.</li><li>Participate in an on-call rotation schedule to ensure 24/7 availability and timely response to critical incidents</li>"},{"text":"What You Will Need","content":"<li>5+ years Experience as a DevOps Engineer with a focus on database management</li><li>Hands-on experience with cloud platforms (AWS or GCP)</li><li>Proficiency in scripting languages such as Go, Shell, and Ruby for automation tasks</li><li>Experience with infrastructure as code tools (e.g., Terraform, CloudFormation) for provisioning and managing database resources</li><li>In-depth knowledge of database systems such as MySQL, PostgreSQL, MongoDB, etc., including configuration, optimization, and troubleshooting</li><li>Strong understanding of CI/CD practices and tools</li><li>Experience with disaster recovery strategies (including hands-on backup and recovery experience)&nbsp;</li><li>Experience in configuration management tools (eg: ansible) for database patching and maintenance automation</li>"}],"text":"Senior DevOps Engineer - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.</div>","descriptionBodyPlain":"About the Role\n\nThe Senior DevOps Engineer position, specifically with expertise in design, administration, high availability, operational support, and automation experience with databases will join a growing and high-energy team supporting internal products and platforms. As a Senior DevOps Engineer, you will be responsible for providing the highest technical expertise for the engineering, planning, design, implementation, upgrade, patching, capacity planning, automation, and day-to-day operations for the various distributed databases (Postgres, Mongo, MySQL, ES, Redis, etc.) that we offer. This role will also provide oversight, mentoring, and leadership opportunities. The successful candidate must be comfortable working on multiple dynamic projects simultaneously, collaborating with database architects, principal engineers, application teams, information security teams, and leadership at all levels of the organization.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b","applyUrl":"https://jobs.lever.co/GoToGroup/28fe323b-ed5f-482b-b71d-ed60662bed8b/apply"},{"additionalPlain":"About the Team\n\nMeet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.\n\nGoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).\n\nPsst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Meet the team that has been instrumental in Gojek's growth! We served more than 200 million transactions every month! Also, we strengthen the business group by having deeper knowledge about what are the best recommendations and promotions that are suitable for the customer's needs. From recommending what is the best meal to cheat your diet at 10 pm or offering the latest promotion near your place, we always seek how to extend the product value through our most up-to-date data and marketing solution.</div><div><br></div><div>GoFood Growth pod consists of more than 50 persons that consist of different roles, we seek to improve ourselves by learning from everyone. You will get to meet with almost every team there is in Gojek, from the Product Manager, Data Science, to the Operation team. This team is the melting-pot for the Econ, Marketeers, and Data geeks. While the script running and the campaign launching, we often kill the time by fooling around by imposing ourselves in Among Us or building an alibi as the \"Loyal servant of the Arthur\" in Avalon (hey, I'm not the minion guys 😃).</div><div><br></div><div>Psst, at the moment we are aiming to upgrade our operation through automation and machine learning. If you are interested in solving business problems through the latest cutting-edge data solution, this is the right place for you!</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1706508052225,"descriptionPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","id":"da8d4a37-f5a4-4436-8743-58c787781285","lists":[{"text":"What You Will Do","content":"<li>Take ownership of one of OKR related to demand and growth that leads to revenue and profitability from one of Gojek product’ business; defines the strategy and roadmap for the team to achieve it by combining multiple initiatives (e.g., content/communication, vouchers/promotion, product changes)</li><li>Discover growth opportunities in the business metrics and customer metrics by exploring business data, transaction data, customer activity within apps and actual customer insights</li><li>Build predictive model or clustering model to allocate the promo allocation efficiently</li><li>Run multiple experiments to validate hypothesis in fast pace iteration cycle</li><li>Drives the team for prioritization, strategy, and focus on solutions to solve user problems</li><li>Introduce beneficial business changes through well-written strategy documents and validate the strategy and hypotheses through robust experimentation and statistical approach</li><li>Optimize and automate solutions by leveraging Data Sciences resources</li><li>Perform feedback loop and retroactive analysis of the team performance and operation to evaluate and improve their impact on Gojek’'s North Star Metrics</li><li>Proactively review the operation process in the team and act on how to drive a faster, effective, and efficient execution process</li><li>Present findings to senior management to drive business and strategic decision-making on feature prioritization and impact analysis.</li>"},{"text":"What You Will Need","content":"<li>BS/MS in Engineering, Computer Science, Math, Statistics, or equivalent experience</li><li>Minimum 5 years of working experience with a minimum of 1-2 year of leadership experience</li><li>Proficiency in data analysis tools and programming languages such as Python, R, SQL, and data visualization tools like Tableau or Power BI. Strong analytical skills to interpret complex data sets and extract actionable insights</li><li>High proficiency in Experiment and Hypothesis Testing for multiple scenarios of business</li><li>High proficiency in Descriptive Analytics, Predictive Analytics, Clustering analytics</li><li>Understanding of business operations, strategies, and objectives. The Consumer Analytics Lead should be able to connect analytical insights to business goals and contribute to overall decision-making</li><li>Data Management: Familiarity with data collection, storage, and management best practices</li><li>Strong business acumen with successful experience influencing and leading cross-functional teams</li><li>End to end the problem-solving mindset that can work in increments and exponents</li><li>Radical Candor leadership while also a strong team player; possessing team synergy skills with a high level of enthusiasm in collaborating in a cross-functional team and can also balance attention to detail with swift execution</li><li>Strong project management skills to manage complex projects, also can manage and prioritize multiple internal and external stakeholders</li><li>Experience in a SaaS, Marketplace, Food Delivery, or other technology company is a plus</li>"}],"text":"Senior Growth Manager - Food & Ads","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Here comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience &amp; behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nHere comes a new challenge for you who is seeking the next leap in your career growth, being our Growth Manager for GoFood! In this role, you will lead problem-solving processes and execute solutions with focus on improving demand and growth metrics for GoFood. Combining business strategy and customer experience & behavior analysis, you will do experiments and campaigns that will encourage our users to experience the product’s core value as quickly as possible which will also improve the product's account spending. In short, you’ll get out of bed every day thinking about new ways to solve exciting problems and grow the business, how cool is that!\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285","applyUrl":"https://jobs.lever.co/GoToGroup/da8d4a37-f5a4-4436-8743-58c787781285/apply"},{"additionalPlain":"About The Team\n\nThe mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.\n\nThe Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.\n\nIn addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>The mission of the Gojek Data organization is to elevate user satisfaction, foster trust, and deliver significant value to both our customers and company through advanced data analytics. Our team manages a spectrum of critical technologies including data platforms, data science platforms, data streaming (Daggers, Firehoses), and batching products (Optimus). We also collaborate closely with customer engagement and insights platforms such as Marketing Comms, experimentation, segmentation, and product analytics, all of which play pivotal roles in Gojek’s offerings—from dynamic pricing and driver allocation to food recommendations and fraud prevention.</div><div><br></div><div>The Data organization supports all user personas across the entire data lifecycle, from data ingestion through transformation, utilizing analytics and experimentation to extract meaningful insights. Many of our products are open source and accessible on Github, underscoring our commitment to transparency and collaboration.</div><div><br></div><div>In addition to driving company growth, we prioritize the personal development and well-being of every team member. We are dedicated to leveraging intelligent technology and innovative engineering approaches to simplify daily life. Furthermore, we share a passion for chai, movies, and TV shows, which contributes to our vibrant team culture.</div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Jakarta","team":"-","allLocations":["Jakarta","Bengaluru"]},"createdAt":1721729849780,"descriptionPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","description":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","id":"e6583aa0-7097-4e6f-9f91-7f24d5441156","lists":[{"text":"What You Will Do","content":"<li>Develop and communicate a clear product vision and roadmap for data science/GenAI platforms/products, and Streaming/Batching Pipeline products.</li><li>Lead the end-to-end product development lifecycle from ideation through launch and iteration, aligning product strategies with business objectives and stakeholder needs.</li><li>Collaborate closely with cross-functional teams, including engineering, data science, analytics, and operations, to deliver high-quality products.</li><li>Prioritize features and improvements based on data analysis, user feedback, and business impact.</li><li>Utilize data-driven insights to inform product decisions and measure the impact of product features.</li><li>Implement and track key performance indicators (KPIs) to ensure product success and drive continuous improvement.</li><li>Foster a culture of experimentation and iteration to optimize product performance and user satisfaction.</li><li>Communicate product updates, progress, and challenges effectively to stakeholders at all levels of the organization.</li>"},{"text":"What You Will Need","content":"<li>5+ years of product management experience, specializing for at least 3 years in data science platforms, data pipelines, or related products.</li><li>Proven track record of successfully managing complex technical products in fast-paced environments.</li><li>Strong understanding of data science, and data engineering principles.</li><li>Experience with streaming and batching data processing technologies such as Apache Kafka, Spark, Flink, etc will be a big plus.</li><li>Strong analytical and problem-solving skills, leveraging a data-driven approach to decision-making.</li><li>Excellent verbal and written communication skills.</li><li>Demonstrated leadership abilities, capable of inspiring and motivating cross-functional teams.</li>"}],"text":"Senior Product Manager, Data Science Platform and Data Products","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</div><div><br></div><div>As a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.</div><div><br></div><div>We are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.</div><div><br></div>","descriptionBodyPlain":"About The Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nAs a Product Manager, you'll engage with business users, data scientists, data engineers, and other data consumers to identify their needs and translate them into platform capabilities. We solve software engineering problems for data users, and you will be the bridge between these two worlds.\n\nWe are seeking an experienced Senior Product Manager to lead the development and growth of our Data Science Platform, including GenAI platforms/products and Streaming/Batching Pipeline products. This role is essential for enabling our data consumers to deliver insights and products efficiently, ensuring seamless data flow across the organization.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156","applyUrl":"https://jobs.lever.co/GoToGroup/e6583aa0-7097-4e6f-9f91-7f24d5441156/apply"},{"additionalPlain":"About The Team\n\nOur Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. \n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Marketing Team is a curious, collaborative, and result-driven individuals who love helping merchants succeed. We're a group with diverse skill sets, but we're united in our passion for developing innovative marketing strategies that drive real results. From crafting engaging content to analyzing customer data, we're always up for a challenge and constantly pushing ourselves to learn and grow. </div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Offline Merchants","allLocations":["Jakarta"]},"createdAt":1717126992883,"descriptionPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","description":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","id":"50c8a826-2076-40a3-a829-b96b29c9647f","lists":[{"text":"What You Will Do","content":"<li>Conduct research to understand merchants needs and behavior and analyze product performance data to identify opportunities&nbsp;</li><li>Developing and executing a data-driven marketing strategy that aligns with the overall business objectives</li><li>Create product positioning and messaging to differentiate our products from competitors</li><li>Creating and managing marketing campaigns across various channels, including search, social media, and email marketing by working together with both internal and external stakeholders to deliver the plan</li><li>Developing and managing referral or other marketing programs to drive merchant acquisition</li><li>Identify, develop, implement, and refine consumer-focused lifecycle &amp; retention marketing strategies</li><li>Continuously monitor and analyze data to create campaign or marketing reports</li><li>Running A/B tests and analyzing results to optimize conversion rates and user acquisition.</li>"},{"text":"What You Will Need","content":"<li>3+ years working experience in Tech, Bank, Consulting or Marketing Agencies</li><li>2+ years experience in marketing or growth roles</li><li>Customer obsession and passionate in marketing</li><li>Strong analytical skills, data-driven and delighted with statistical analysis and figures</li><li>Strong communication skills, collaborative spirit, delighted to work with other stakeholders (BI/Data, Business, Product, Leadership)</li><li>Strong business sense and problem-solving skills</li>"}],"text":"Senior Product Marketing Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>We are looking for a Product Marketing Manager (merchant services)&nbsp; for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.</div>","descriptionBodyPlain":"About The Role\n\nWe are looking for a Product Marketing Manager (merchant services)  for GoTo Financial who will be responsible for developing and executing go-to-market strategies esp by orchestrating campaigns or marketing initiatives to drive adoption and revenue growth by identifying opportunities to expand the customer base and increase revenue. The PMM will work closely with the internal marketing team (creative, CRM, event), cross-functional teams (incl product management, customer support, and sales), and external agencies to gather insights, design and execute campaigns, and create sales enablement materials. The ideal candidate will have experience in product management or marketing, excellent communication skills, and the ability to work independently in a fast-paced environment.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f","applyUrl":"https://jobs.lever.co/GoToGroup/50c8a826-2076-40a3-a829-b96b29c9647f/apply"},{"additionalPlain":"About The Team\nOnline Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Online Merchants Sales team consists of experienced sales managers and account managers who handle Midtrans’ most strategic accounts on a day-to-day basis. The team is filled with energetic individuals who are solid team players, who support each other, who celebrate each other with peer-to-peer recognition initiatives.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1722243132222,"descriptionPlain":"About The Role\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","id":"afd9e752-82f0-4b4f-a4ef-5d86dcce1063","lists":[{"text":"What You Will Do","content":"<li>Act as the lead point of contact for all account matters, anticipate the client’s needs, work within the company to ensure deadlines for the client are met, and help the client succeed</li><li>Resolve account issues and complaints</li><li>Plan and present reports on account progress, goals, and periodic initiatives to share with team leaders and peers on a regular basis</li><li>Provide full visibility into the sales pipeline at every stage of engagement, and take the account into the next level by increasing Midtrans’ share in online payments</li><li>Develop a strong understanding of the e-commerce and digital commerce market and be the first person that a client calls for escalation</li><li>Work closely with the Partnership and Banking teams to ensure rapport and collaboration between partners and clients</li><li>Responsible for administrative duties, such as preparing reports, preparing price quotes, maintaining and approving the entire agreements and forms</li>"},{"text":"What This Role Needs","content":"<li>Bachelor’s degree in Business Management, Sales, Communication or related academic area</li><li>At least 6 years of experience in business management, sales, or project management is mandatory. Prior experience in e-commerce and managing key accounts will be a plus point</li><li>Fluency in both Bahasa and English is required</li><li>Able to multitask, prioritize, and manage time efficiently</li><li>Ability to negotiate, persuade and influence others</li><li>Excellent interpersonal, communication, presentation and analytical skills</li><li>Proficient computer skills, and experience with CRM software and the Microsoft Office Suite, with emphasis on superior Excel skills</li><li>Proven ability to maintain projects and maintain effective relations with accounts or partners</li>"}],"text":"Senior Sales Manager - Midtrans","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">Sales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.</span></div>","descriptionBodyPlain":"About The Role\nSales in Midtrans plays an important role to acquire, execute, and maintain partnerships with the most strategic startup and offline-to-online (O2O) businesses in the company’s portfolio. You will assist the Commercial Department in sales functions, including end-to-end management and executing all partnerships' contractual assets that help drive the company's key business goals.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063","applyUrl":"https://jobs.lever.co/GoToGroup/afd9e752-82f0-4b4f-a4ef-5d86dcce1063/apply"},{"additionalPlain":"About the Team\n\nThe Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Finance Information System team is part of the larger IT Enterprise Systems Team under CIO Organization. IT Enterprise Team governs, manages, and helps GoTo Enterprise applications globally. The office of the CIO is charged with leading the company's information technology strategy and implementation. All internal and enterprise systems are maintained and implemented by the CIO’s team; they look after a variety of systems, including (but, not limited to): finance, people services, productivity, operations, internal security login, authentication, account authorization, account audits, and email. The office of the CIO also leads all IT asset procurement, budgeting, and implementing equipment policies.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"HoldCo - CIO","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721742951306,"descriptionPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","description":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","id":"099498bc-c171-4505-97d7-3a432d302e14","lists":[{"text":"What You Will Do","content":"<li>Work and collaborate in Financial systems technical projects, especially in SAP ABAP and SAP BTP technologies</li><li>Collaborate with cross-functional and cross-department teams to analyze complex business requirements and design scalable solutions</li><li>Develop and maintain technical specifications, design documents, and other project artifacts</li><li>Provide technical support and guidance to development teams, ensuring high-quality code delivery</li><li>Participate in code reviews, ensuring adherence to coding standards and best practices</li><li>Contribute to the development of technical architecture and design patterns, providing recommendations for improving performance, scalability, and maintainability</li><li>Stay up-to-date with the latest SAP technologies and trends, and evaluate new technologies for potential adoption</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of experience in SAP application development, with a focus on SAP ABAP and SAP BTP technologies</li><li>Proven track record of delivering successful scalable technical projects</li><li>Strong technical skills in ABAP OO, SAP Gateway, CDS, AMDP</li><li>Strong technical skills in SAP BTP or SAP Integration Suite</li><li>Knowledge on modern integration, Unix environment, cloud platform technologies, and other stacks is a plus</li><li>Excellent communication and interpersonal skills, with the ability to work effectively in a team environment</li><li>Strong analytical and problem-solving skills, with the ability to think creatively and strategically</li>"}],"text":"Senior SAP Technical","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt;\">In this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.</span></div>","descriptionBodyPlain":"About the Team\n\nIn this role, you’ll support and assist the Finance Accounting and Tax (FAT) team in generating accurate and timely financial reports for the company. Collaborating with Functional Support and Data Engineers, you’ll also deliver high-performing technical solutions, especially in Financial Systems. You’ll have ample opportunity to flex and hone your SAP Technical abilities, utilize the SAP up-to-date products, ensure the team is kept up and running seamlessly, and support their business as usual.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14","applyUrl":"https://jobs.lever.co/GoToGroup/099498bc-c171-4505-97d7-3a432d302e14/apply"},{"additionalPlain":"About Us\n\n Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About Us</b></div><div><br></div><div><span style=\"font-size: 16px\">&nbsp;Automation Engineering Platform is a team that is responsible for creating tools, frameworks, and processes for Quality Assurance (QA) teams within GoTo. The primary objective of team is to ensure that the QA team has all the necessary resources to effectively and efficiently carry out their tasks. These resources include automation frameworks, custom-built tools, and process improvements that enable the QA team to work smarter and faster.</span></div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1706837996316,"descriptionPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","id":"93b5e2e0-272f-4091-b7aa-fafc06ca67c4","lists":[{"text":"What You Will Do","content":"<li>Conduct feature and exploratory tests on Mobile apps (Android, iOS)and API. Engage in continuous automation throughout agile development iterations to ensure zero defects</li><li>Work closely with the cross-functional product team, including PMs, Designers, Developers, and QA managers right from the inception of features</li><li>Create and execute the test cases for features with minimum guidance and maintain and add new cases in automation frameworks on either UI/API test level and reduce manual efforts during regression testing&nbsp;</li><li>Participate in iteration planning, providing input on required testing tasks, processes, and associated effort for the selected user stories</li><li>Design, develop and execute test automation for relevant areas of ownership independently</li><li>Contribute to automation framework development (Libraries / new features / extensions)</li><li>Provide automated test coverage for corner cases, revenue, impact, usability, backend services, and exploratory testing</li><li>As a fast learner and team player, you’re comfortable teaching yourself new skills quickly and can thrive in a complex and fast-paced environment while making strong technical individual contributions</li>"},{"text":"What You Will Need","content":"<li>4-6+ years of experience in the field of professional testing</li><li>Good prior experience in Manual &amp; Automation test methodologies</li><li>Sound knowledge of testing/automating the tests at different layers of the application</li><li>Comfortable writing clean code in one programming language (Java/Kotlin is a plus)</li><li>Good Understanding of Tools like Selenium, Appium, Cucumber BDD, TestNG Maven/Gradle, and CI/CD tools like Jenkins, GitLab, etc</li><li>Should have exposure to tools like Postman, Charles Proxy/MITM&nbsp;</li><li>Working knowledge of Git</li><li>Experience in developing test automation framework from scratch is a big plus</li>"}],"text":"Senior SDET - Automation Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs an engineer in Automation Engineering platform you will be responsible to lead and implement the test strategy for automation by working closely with the product engineering group, design and develop tools and frameworks that help smoother development and testing process. You will also work on the latest cutting-edge internet/software technology.\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4","applyUrl":"https://jobs.lever.co/GoToGroup/93b5e2e0-272f-4091-b7aa-fafc06ca67c4/apply"},{"additionalPlain":"About our Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About our Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1700733541559,"descriptionPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","description":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","id":"472ae629-87cb-4f8c-bb69-eae35cf3751e","lists":[{"text":"What you’ll do","content":"<li>Develop and implement test automation tools and frameworks to ensure continuous testing of product features</li><li>Collaborate with product managers and engineers to understand requirements, document test cases, and define rollout/release strategies</li><li>Perform performance, load, and scalability testing for new features and product releases.</li><li>Debug and diagnose defects uncovered during testing to determine root causes. Log bugs accurately and communicate issues clearly to engineering teams</li><li>Monitor systems in production to identify and troubleshoot defects or anomalous behavior.</li><li>Stay up-to-date with new testing methodologies and tools</li><div><br></div><div><br></div>"},{"text":"What you’ll need","content":"<li>5+ years experience in a QA, SDET or DevX role, with expertise in test automation</li><li>Proficiency with one or more programming languages like Java, Go, Kotlin, Python</li><li>Experience testing complex distributed systems and microservices architectures</li><li>Understanding of SQL and NoSQL databases</li><li>Familiarity with technologies like Kafka, Docker, Kubernetes</li><li>Knowledge of financial systems, mobile apps, or SaaS products is a plus</li><li>Excellent verbal and written communication skills</li>"}],"text":"Senior SDET - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role:</b></div><div><br></div><div>We are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,&nbsp; you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role:\n\nWe are looking for an experienced Senior SDET Engineer to join our engineering team at GoTo Financial. You will be responsible for establishing testing standards and strategies to ensure product quality and performance. As a senior engineer,  you will work on our flagship products across GoTo, including Tokopedia and Gojek, ensuring our millions of users get the best experience.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e","applyUrl":"https://jobs.lever.co/GoToGroup/472ae629-87cb-4f8c-bb69-eae35cf3751e/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team :</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721811900324,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","description":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","id":"153e42ca-cf5b-4f43-b09e-58eabda1e5fa","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 4 years of experience in professional testing in App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin, experience with Flutter is a plus)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role :</b></div><div><br></div><div>As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa","applyUrl":"https://jobs.lever.co/GoToGroup/153e42ca-cf5b-4f43-b09e-58eabda1e5fa/apply"},{"additionalPlain":"About the Team :\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.  \n\n","additional":"<div><b><span style=\"font-size: 16px\">About the Team :</span></b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Consumer Experience team, you will be responsible for products to improve GoPay usage of Gojek and GoPay applications. This team is also responsible for the platform products like communication framework and mobile app experience.&nbsp;&nbsp;</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1722316158497,"descriptionPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role :</span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</span></div>","id":"78d59624-b02e-4370-b23b-25677dfb1b20","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and SDET/QA) right from the inception of features</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation</li><li>Understand business and product requirements as related to payments and the existing service architecture</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity</li><li>Take responsibility for the quality of features and the delivery of the entire feature&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least a minimum 5 years of experience in professional testing in Microservices/API/App/Web</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin)</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (automation + manual)</li><li>Excellent analytical, debugging skill and problem solving with attention to detail</li><li>Well-versed with Agile methodology, SDLC and STLC</li>"}],"text":"Senior SDET - Consumer Payments","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role :</span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"About the Role :\n\nAs a Sr SDET engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology. We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion in building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20","applyUrl":"https://jobs.lever.co/GoToGroup/78d59624-b02e-4370-b23b-25677dfb1b20/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Bengaluru","team":"Payment Core","allLocations":["Bengaluru"]},"createdAt":1713506558950,"descriptionPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","description":"<div><span style=\"font-size: 10pt\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","id":"076bd021-0157-42a4-89fd-51d9f236e490","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features;&nbsp;</li><li>Participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Write concise, comprehensive, detailed test plans based on business and product feature requirements;&nbsp;</li><li>Improve the test automation experience by enhancing tools/scripts, test coverage, and/or code structure, and automate repeated manual tasks to improve self/stream's productivity;&nbsp;</li><li>Take responsibility for the quality of features and the delivery of the entire feature;&nbsp;</li><li>Debug and analyze the bugs in the application/service, aiding developers in arriving at the root cause</li>"},{"text":"What You Will Need","content":"<li>At least 5 years of experience in professional testing in Microservices/API/App/Web;&nbsp;</li><li>Hands-on in test automation using any language (preferably Java &amp; Kotlin);</li><li>Hands-on in Flutter automation is a plus;</li><li>Experience with open-source automation libraries like Rest Assured, Appium, and Selenium;</li><li>Familiarity with CI/CD tools like Gitlab, and Jenkins;</li><li>Deep knowledge in manual &amp; automation test methodologies and principles; 60+40 (&nbsp; auto + manual)</li><li>Excellent analytical, debugging skills and problem-solving with attention to detail;</li><li>Well-versed with Agile methodology, SDLC and STLC;</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Senior SDET - Payment Widget & Vendor Gateway","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.</span></div><div><br></div><div><span style=\"font-size: 10pt;\">We are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.</span></div>","descriptionBodyPlain":"As a Senior QA engineer —you would need to be able to lead and implement the test strategy for manual as well as automation by working closely with the product engineering group. They would also work on the latest cutting-edge internet/software technology.\n\nWe are looking for passionate individuals who want to make a difference in the world, have a strong will of constant learning and development, are open and collaborative, and never stop striving to improve and develop both themselves and the products they are responsible for. Here at GTF, we want to share our passion for building the best products using amazing technology while having great fun doing it.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490","applyUrl":"https://jobs.lever.co/GoToGroup/076bd021-0157-42a4-89fd-51d9f236e490/apply"},{"additionalPlain":"About the Team\n\nThe Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.\n \nSome of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few. \n \nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Marketplace Product Development team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace. We are responsible for the pillars of technology, science, and strategy across the supply and demand. More specifically, we optimally match customer orders across Gojek (Food, Transport, etc.) with the right driver partners at the right time and location. We are the brains of Gojek's on-demand nature, matching millions of orders a day. This supply and demand matching is the core problem that our Product Team tackles every day, designing products and services that solve this ever-evolving challenge. The efficiency of our matching technology directly impacts customer and driver-partner experience, as well as the unit economics of the platform.</div><div>&nbsp;</div><div>Some of the key problem statements that our team works on are: how to intelligently pair driver partners to customers to provide the quickest pickup times, how to make our service more affordable by pairing demand on overlapping routes, and how to fairly distribute customer orders across our driver base, just to name a few.&nbsp;</div><div>&nbsp;</div><div>Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Marketplace","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1698659237440,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","id":"8d7ae844-168c-4e78-843a-94aceb7b1a66","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of relevant, hands-on experience with either  Golang, or Java</li><li>Ability to go in-depth across tech stacks used in the product</li><li>Experience working on large-scale, event-driven microservice architecture with active use of Kafka; ability to architect solutions based on this pattern</li><li>Familiarity with basic programming principles such as SOLID and TDD</li><li>Intermediate experience with Linux OS; ability to troubleshoot issues</li><li>A solid understanding of why we need to test code; experience implementing tests</li><li>Ability to understand/discuss design and performance trade-offs in complex systems</li>"}],"text":"Senior Software Engineer  - Marketplace","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Roll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.</div><div><br></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our Senior Software Engineer. In this role, you will be an integral player in the Marketplace team based in Bangalore, India. With knowledge of building scalable applications, current user trends and preferences, and emerging technologies in the field, you'll get your hands dirty in designing, managing, and improving various applications within the Marketplace stream. You'll also enhance the engineering platform and cloud infrastructure used by all engineers, thereby improving the team's overall productivity. In our humble opinion, the coolest part of this role is your ability to own the future of these products, ensure its quality and longevity, and see the results of your efforts in people's every day lives.\n\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66","applyUrl":"https://jobs.lever.co/GoToGroup/8d7ae844-168c-4e78-843a-94aceb7b1a66/apply"},{"additionalPlain":"About the Team\n\nWe are a team of developers, designers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform & Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions. \n\nThis includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.\n\nCombating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of developers, designers and product managers with diverse academic, professional and personal backgrounds but united by the passion to enrich Data Platform &amp; Analytics at Gojek through sound methods and ease of use. Working alongside the Product Managers, BI Analytics and Product Engineers, we are predominantly concerned with utilizing and translating data into critical information that can be used to make sound business decisions.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This includes gathering any new data points, and working closely with various business teams to capture, connect, and convert any data changes into useful knowledge in guiding our next steps to create a meaningful business impact.</span></div><div><br></div><div><span style=\"font-size: 16px\">Combating remote work has brought us even closer, with frequent catch-ups over tea and sharing ways we have been keeping ourselves sane. Along with our desire to utilize smart technology and innovative engineering strategies to make people’s lives easier, our team also bonds over our shared love for reading, gaming, and drinking lots of coffee. We work hard and play hard, and believe it or not, we actually enjoy each other’s company!</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Data Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1722246725855,"descriptionPlain":"About the Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nThis role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">This role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more</span></div><div><br></div>","id":"d8170197-90ca-4f87-a48d-d1a3175538ce","lists":[{"text":"What You Will Do","content":"<li>Code, Design, prototype, perform reviews and consult in building highly scalable, reliable, and fault-tolerant systems</li><li>Containerisation and deployment of microservices on Kubernetes</li><li>Auto-scaling and monitoring performance of the streaming Infrastructure and applications by using Prometheus and Grafana or similar tools</li><li>Collaborate with the team to ensure that the service level objectives and agreements are achieved</li><li>Communicate and collaborate effectively with product, data science teams</li><li>Continue to stay abreast of the latest technologies in Event processing and Big Data space to inform/suggest new technologies and best practices to trial</li><li>Mentor and guide other engineers in the team</li>"},{"text":"What You Will Need","content":"<li>At least 4+ years of software engineering experience</li><li>Experience with containerization and DevOps, including Docker and Kubernetes</li><li>Experience with Kafka and stream processing like Flink or Spark Streaming</li><li>Must have hands-on experience using any of the cloud platforms (AWS, GCP, Azure), with thorough knowledge of cloud concepts</li><li>Demonstrated ability to take initiative and accountability for achieving results</li><li>Strong interpersonal and communication skills</li><li>Passion for learning new things and solving complex engineering blockers</li>"}],"text":"Senior Software Engineer - Data Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">You've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px;\">This role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more</span></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nYou've got an appointment, so you open your Gojek app to order a ride. Behind the scenes, we run numerous data streaming jobs and machine learning models within seconds to provide you and our partners with the best possible experience. However, managing the underlying data engineering and science infrastructure in production is more challenging than it should be. That's where our team comes in. Our promise to business users, data scientists, and data engineers is simple: focus on your core responsibilities while we handle the complex engineering problems. \n\nThis role is for the Platform Engineering team under Gojek's Data Platform vertical. You’ll be responsible for building, shipping, and growing platform products, which are core pillars of data engineering. The roles comprise responsibilities for products like data processing, authentication/authorisation, infrastructure, Observation, orchestration, and more\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce","applyUrl":"https://jobs.lever.co/GoToGroup/d8170197-90ca-4f87-a48d-d1a3175538ce/apply"},{"additionalPlain":"About the Team\n\nGojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Gojek’s Data Science Platform team helps Data Scientists build production-scale ML applications easily. We are a team of about 10 ML and infrastructure engineers, spread across Indonesia and Singapore. You may know us as the creators of open-source MLops technologies such as Feast, Merlin and Turing. Our products are used in mission-critical parts of Gojek’s product offerings, such as driver allocation, food recommendations, and fraud prevention.</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1711358848361,"descriptionPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","id":"68f907a3-329f-411b-af2d-a66b38243919","lists":[{"text":"What You Will Do","content":"<li>Design and build our Machine Learning Platform to help Data Scientists productionize their models and features faster</li><li>Engineer high-reliability, high-performance services for sophisticated ML-driven functionality</li><li>Collaborate with Data Scientists to optimize ML models for high-throughput, low-latency use cases</li><li>Build internal tools and interfaces to improve the productivity of the team and improve the accessibility of our products</li>"},{"text":"What You Will Need","content":"<li>At least 5 years as a Software Engineer, with fluency and experience in either Go, Python, or Java</li><li>Proven track-record building large-scale, high-throughput, low-latency production systems</li><li>Prior experience developing for and debugging Big Data and stream processing frameworks such as Spark, Kafka, and Flink</li><li>Good understanding of algorithms and data structures/ design patterns</li><li>Passion for Agile software development practices such as test-driven development, pair programming, etc.</li><li>Experience with relational databases, non-relational databases, cloud environments and cloud deployment technology (Terraform, Kubernetes, Helm)</li><div><br></div>"},{"text":"Bonus Points If","content":"<li>You have working knowledge of ML frameworks such as TFX, Kubeflow, and MLflow</li><li>You have Data Science knowledge and familiarity with ML libraries such as Pandas, Scikit, Tensorflow, XGBoost, Keras</li>"}],"text":"Senior Software Engineer - Data Science Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">Data Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.</span></div><div><br></div><div><span style=\"font-size: 16px;\">Most companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nData Scientists want to spend their time exploring data, crafting the right features and optimising their models… so far so good. Production requires a lot more though. What about the data pipelines? Scaling up infrastructure based on demand? Running experiments at scale? Feature data consistency? This is where you come in as a Software Engineer for Gojek’s ML platform.\n\nMost companies embed ML engineers in data science teams to solve these problems. We do things a little differently at Gojek. We build self-service products for data scientists so they don’t have to worry about deep engineering problems. Create your model and submit it to us, our platform will scale it up/down for you.\n\nYou will be joining a team that has already built industry-leading open-source tools. Our team invented Feast which companies like Twitter and Shopify now use. MLOps is changing fast, we’re looking for engineers who are keen to build the next big thing in MLOps.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919","applyUrl":"https://jobs.lever.co/GoToGroup/68f907a3-329f-411b-af2d-a66b38243919/apply"},{"additionalPlain":"About the Team\n\nWe are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.\n\nWe keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.\n\nThe Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are a team of 4 engineers, focusing on Platform concerns, under the Mobility Marketplace group. Our prime objectives include platformization, reliability concerns of systems within the marketplace and aim to move towards a composable architecture where new features could be shipped for experimentation by business in a matter of days. We act as a central binding agent for Pricing, Supply and Matchmaking teams and make sure that the overall architecture and infrastructure is flexible, easily extensible and scalable.</span></div><div><br></div><div><span style=\"font-size: 16px\">We keep pondering about how we could improve availability of the systems by introducing tools to configure and operate clustered solutions. how could we be more agile in on-boarding new use-cases to enable opportunities to Mobility Marketplace business? We bounce around ideas and debate with the above themes in mind. Combating remote work has brought us even closer with frequent catch-up for chit-chat over tea and empathy for each other.</span></div><div><br></div><div><span style=\"font-size: 16px\">The Marketplace Product Development Team at Gojek handles the hardest quantitative problems related to improving Gojek's real-time marketplace which deeply impacts the everyday experiences of our customers (riders) and drivers.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721898140037,"descriptionPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","id":"57bb5e7f-9ea0-462f-ac36-5717b49d0380","lists":[{"text":"What You Will Do","content":"<li>Takes responsibility for the entire lifecycle of their stories: development, test, production, and subsequent fixes and improvements</li><li>Reaches out to stakeholders to clarify the requirements for the story they are working on</li><li>Improves the development experience at Gojek by enhancing development tools, test coverage, and/or code structure</li><li>Manages timely delivery for own tasks consistently</li><li>Actively supports their team in the tracking and reporting of execution metrics both through automation as well as disciplined adherence to processes and best practices</li><li>Has an in-depth understanding of at least one programming language and framework</li><li>Performs code reviews that follow the standards and practices of the engineering handbook and that are recognized by their team as helpful</li><li>Collaborates with other engineers, designers and QAs to flesh out implementation details based on the established pattern in the stream</li><div><br></div>"},{"text":"What You Will Need","content":"<li>4-5 years of relevant experience. Hands-on in either Golang or Java</li><li>The ability to go into depth and breadth across tech stack used in the product vis-a-vis backend services, machine learning, data engineering, web development, data and analytics, infrastructure</li><li>Has worked on large scale event driven microservices architecture with an active use of Kafka and can architect solutions based on this pattern</li><li>Is familiar with basic programming principles such as SOLID and TDD</li><li>Has intermediate experience with Linux and is able to troubleshoot issues</li><li>Understands why we need to test code and has implemented tests</li><li>Able to understand/discuss design and performance trade offs in complex systems</li><div><br></div>"}],"text":"Senior Software Engineer - Go-food","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">As a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.</span></div><div><span style=\"font-size: 16px;\">You would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a senior software engineer, you'll work closely with product, operations, and engineering teams throughout the company. We value curiosity to explore deeper into the systems, libraries, tools and look for scalable solutions. Familiarity with Event Driven Architecture would be desired.\nYou would be tasked with platformization of the Mobility Marketplace as a first-class problem, which requires understanding end-to-end use-cases and challenge the status quo at all times by reviewing current engineering techniques and tools and scout for opportunities and fundamental engineering changes that would bring agility, reliability to enable more business opportunities.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380","applyUrl":"https://jobs.lever.co/GoToGroup/57bb5e7f-9ea0-462f-ac36-5717b49d0380/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1718187134939,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"53c0b8a9-1a83-4c34-9a59-b5170ce54193","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Senior Software Engineer - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193","applyUrl":"https://jobs.lever.co/GoToGroup/53c0b8a9-1a83-4c34-9a59-b5170ce54193/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev Android role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789054175,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","id":"fda395d6-457d-4a03-aaa1-33d513c3960b","lists":[{"text":"What You Will Do","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Senior Software Engineer (Android) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (Android) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (Android) will be responsible for developing and maintaining our Android applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of Android development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b","applyUrl":"https://jobs.lever.co/GoToGroup/fda395d6-457d-4a03-aaa1-33d513c3960b/apply"},{"additionalPlain":"About the Team\n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713939159820,"descriptionPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","id":"d3b7122b-692b-4815-8aa9-f1d0259bccd5","lists":[{"text":"What Will You Do","content":"<li>Develop Java backend applications for the company, including web applications and server-side applications.</li><li>Be responsible for participating in the entire software development process, from requirement analysis to design, development, testing, and deployment, ensuring that our software products run efficiently and stably. The most significant thing is taking responsibility for results.</li><li>Architect and engineer robust, high-performance systems that can effortlessly handle scale, maintain reliability, ensure security, and gracefully handle faults.</li><li>Craft and refine our product vision into iterative Minimum Viable Products (MVPs), refining them as needed for scalability and adaptability.</li><li>Stay at the forefront of technology trends, continuously evaluating and incorporating new tools and methodologies to supercharge our development efforts.</li>"},{"text":"What Will You Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Consumer Lending (Funding/Collection)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.</div>","descriptionBodyPlain":"About the Role\n\nWe're seeking an adept Software Engineer to join our dynamic engineering team at GoTo Financial. Your primary role will involve crafting and developing cutting-edge fintech applications with a focus on performance excellence. As a senior member of the team, you'll be instrumental in enhancing our flagship products spanning Gojek, GoPay, and Tokopedia, all geared towards delivering optimal user experiences to our extensive user base.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5","applyUrl":"https://jobs.lever.co/GoToGroup/d3b7122b-692b-4815-8aa9-f1d0259bccd5/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Back End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789283382,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","id":"769b7391-e6fd-4923-9a92-e060f14e451d","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis, and MySQL.</li><li>Contributed to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization. Therefore, in addition to technical prowess, a keen understanding of financial business and self-motivation are emphasized.</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major.</li><li>3+ years of Java development experience, those with large-scale project development experience are preferred.</li><li>Highly preferable experience in Golang</li><li>Be familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis.</li><li>Be familiar with Linux operating systems, understand database principles, and be proficient in using databases like MySQL and Oracle.</li><li>Have good coding style and code specifications, and be able to independently complete project development.</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li><li>Have knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Back End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Back End Engineer to join our innovative cryptocurrency company in Jakarta. The Back End Engineer will be responsible for developing and maintaining the server-side logic, ensuring high performance and responsiveness of the applications, and collaborating with front end developers to integrate user-facing elements. This role requires strong technical skills, a deep understanding of server-side technologies, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d","applyUrl":"https://jobs.lever.co/GoToGroup/769b7391-e6fd-4923-9a92-e060f14e451d/apply"},{"additionalPlain":"About the team \n\nOur team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.\n\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the team </b></div><div><br></div><div>Our team works to provide responsible and sustainable financial services to millions of Indonesians. Partnering with other teams in Tokopedia and Gojek, we aim to build the best experience for our users looking for a convenient and safe way to access credit. Though we’re spread across Indonesia, India, and Singapore, we enjoy collaborative development with fast feedback cycles and prefer making pragmatic decisions despite working under many business and regulatory constraints. We work in a highly supportive work environment where we never hesitate to help each other out, unblock barriers, and have fun along the way. We love bonding over our catch-up sessions, where we learn about each other's cultures.</div><div><br></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713777541586,"descriptionPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","description":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","id":"ad7a1160-4d07-4f4a-a2d3-c362afac18ac","lists":[{"text":"What You Will Do","content":"<li>Responsible for developing Java backend applications for the company, with proficiency in Java language and expertise in mainstream frameworks such as Spring, Spring Boot, MyBatis and MySQL</li><li>Contribute to the full lifecycle of the Middle Platform's core system construction, including requirement analysis, solution design, and iterative system optimization</li>"},{"text":"What You Will Need","content":"<li>Bachelor's degree or above in Computer Science or a related major</li><li>4+ years of Java development experience, those with large-scale project development experience are preferred</li><li>Familiar with mainstream frameworks like Spring, Spring Boot, and MyBatis</li><li>Familiar with Linux operating systems, understand database principles, and proficient in using databases like MySQL and Oracle</li><li>Good coding style and code specifications, and be able to independently complete project development</li><li>Good communication skills and teamwork spirit, and be able to collaborate effectively with other developers</li><li>knowledge of container orchestration technologies like Docker and Kubernetes, and be able to use them for application deployment and management.</li>"}],"text":"Senior Software Engineer (Backend) - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>We are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.</div>","descriptionBodyPlain":"About the Role \n\nWe are looking for an experienced Software Engineer to join our engineering team at GoTo Financial. You will be responsible for designing and building high-performance fintech applications. As a senior engineer, you will work on our flagship products across Goto, including Gojek, GoPay, and Tokopedia, ensuring our millions of users get the best experience.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac","applyUrl":"https://jobs.lever.co/GoToGroup/ad7a1160-4d07-4f4a-a2d3-c362afac18ac/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1710229562529,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"10dbc666-80f8-4250-85ee-59fa92d056aa","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Golang.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Good understanding of the full life cycle of the data warehouses.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Data Warehouse)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa","applyUrl":"https://jobs.lever.co/GoToGroup/10dbc666-80f8-4250-85ee-59fa92d056aa/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Front End Engineer role will be reporting directly to the Head of DevOps, Security and System Infra, Security and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721788927036,"descriptionPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","id":"bcd00ee0-2fb3-43c1-8401-ef184283ccc8","lists":[{"text":"What You Will Do","content":"<li>Design, build, deliver, and own development lifecycle from inception to production</li><li>Collaborate with the UI/UX team to write, design, and build high-quality front-end code and reusable components</li><li>Participate in and be responsible for front-end architecture design, and program decision-making, as well as creating technical standards and specifications;</li><li>Try improving engineering standards, tooling, and processes after understanding the business and team’s needs</li><li>Lead others through example, mentorship, teaching, code reviews, advocating, and maintaining suitable engineering standards for the team</li><li>Maintain close relations cross-department and gain from their expertise/share your learnings with them</li>"},{"text":"What You Will Need","content":"<li>3-4+ years of proven track record in JavaScript/ Typescript, CSS , HTML, DOM, network protocol, and other front-end related technologies, have in-depth experience in at least one of the mainstream front-end frameworks (React/ Vue /Angular, etc.) and understand the implementation principle</li><li>Good product awareness, service awareness, and sense of responsibility, can be independent and attention to user experience</li><li>Problem-Solving: Exceptional problem-solving skills with a track record of analyzing complex technical challenges and providing innovative solutions.</li><li>Communication: Excellent communication skills, with the ability to effectively convey technical concepts to both technical and non-technical stakeholders.</li><li>Leadership: Strong leadership experience, including mentorship, and technical guidance</li>"}],"text":"Senior Software Engineer (Front End) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a talented and motivated Front End Engineer to join our innovative cryptocurrency company in Jakarta. The Front End Engineer will be responsible for developing and maintaining user-facing features and interfaces, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of front-end technologies, and a passion for the cryptocurrency industry. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8","applyUrl":"https://jobs.lever.co/GoToGroup/bcd00ee0-2fb3-43c1-8401-ef184283ccc8/apply"},{"additionalPlain":"About the Team\n\nGoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.\n\nThis Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>GoTo Financial, as a part of GoTo Group - the largest technology group in Indonesia, is accelerating financial inclusion through its leading financial services and merchants solutions. The brand’s trusted and inclusive ecosystem of products is built to open new growth opportunities and empower everyone to realize their dream of a better life in the rapidly expanding digital economy.</div><div><br></div><div>This Mobile Dev iOS role will be reporting directly to the Head of DevOps, Security and System Infra, Security, and System Infra of PT Kripto Maksima Koin which focuses on cryptocurrency business in GoTo Financial and is located in Jakarta, Indonesia.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Crypto","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721789167169,"descriptionPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","description":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","id":"e6c36118-5d4e-444b-922c-68e03c2ab82e","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Flutter and iOS.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3+ years of experience with iOS development and Flutter combined</li><li>Proficient in Swift programming, Cocoa, Xcode, the iOS SDK, Dart, and Flutter</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar).</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Crypto","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>We are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.</div>","descriptionBodyPlain":"About the Role\n\nWe are seeking a skilled and motivated Mobile Developer (iOS) to join our innovative cryptocurrency company in Jakarta. The Mobile Developer (iOS) will be responsible for developing and maintaining our iOS applications, ensuring a seamless and engaging user experience. This role requires strong technical skills, a deep understanding of iOS development, and a passion for the cryptocurrency industry.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e","applyUrl":"https://jobs.lever.co/GoToGroup/e6c36118-5d4e-444b-922c-68e03c2ab82e/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>We are responsible for building and growing the customers and payments made through&nbsp; GoPay. GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions of registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</div><div><br></div><div>As part of the Money Management team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Besides the fully homemade features, the team is also working on in-depth integration with bank partners.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1708271973710,"descriptionPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","id":"389c0346-14e0-40e5-85c3-48d830db73b4","lists":[{"text":"What You Will Do","content":"<li>Working with deep expertise in mobile applications on Swift.</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, and communicate project/development status to internal and external teams in a timely fashion.</li><li>Analyze and estimate product features defined by the Product Manager/Product Owner by collaborating with Business, Product, and other Dev teams in close coordination.</li><li>Participating in the design review process, seeking and providing constructive criticism.</li><li>Improving code structure and architecture in service of testability and maintainability.</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentation of how their design and architecture evolve over time.</li><li>Participating in the hiring process when needed.</li>"},{"text":"What You Will Need","content":"<li>3 to 6+ years of experience with iOS development</li><li>Proficient in Swift programming, Cocoa, Xcode, and the iOS SDK</li><li>Experience building cross-platform compatible complex Flutter apps</li><li>Knowledge of State Management Patterns (Bloc or similar)</li><li>Strong understanding of iOS app architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third-party libraries for networking, async, image loading, etc.</li><li>Good analytical, problem solving and debugging skills</li>"}],"text":"Senior Software Engineer (iOS) - Money Management","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</div>","descriptionBodyPlain":"About the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large-scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, and collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4","applyUrl":"https://jobs.lever.co/GoToGroup/389c0346-14e0-40e5-85c3-48d830db73b4/apply"},{"additionalPlain":"About The Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. \n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About The Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider. </span></div><div><br></div><div><span style=\"font-size: 10pt\">Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</span></div><div><br></div><div><span style=\"font-size: 10pt\">As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Data Products & Infra","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899734506,"descriptionPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","description":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","id":"449dd201-2d4d-47a0-9cd4-c7ddec91c88e","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain scalable data streaming products for building a self-serve data engineering platform.</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Containerization and deployment of the data products on Kubernetes</li><li>Design and deploy the data products Google Cloud Platform or any other cloud.</li><li>Collaborate with data and business teams to gather requirements and translate them into technical specifications.</li><li>Document processes, architectures, and workflows, and provide training and support to team members.</li>"},{"text":"What You Will Need","content":"<li>A minimum of 2-5 years of experience in a software engineer role, coupled with a graduate degree in a relevant field such as Computer Science.</li><li>Strong in-depth experience of writing code in Java.</li><li>Good understanding of real-time data streaming technologies like Flink, spark etc.</li><li>Good understanding of containerization, including Docker or Kubernetes.</li><li>Strong analytical skills, the ability to work effectively in cross-functional teams, meticulous attention to detail, self-motivation, adaptability, and a strong sense of ownership</li><li>Strong interpersonal and communication skills</li>"}],"text":"Senior Software Engineer (Real-Time Data Streaming)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>At GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers.&nbsp;</div><div><br></div><div><span style=\"font-size: 10pt;\">As a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.</span></div>","descriptionBodyPlain":"About The Role\n\nAt GoToFinancial, engineering is central to everything we do: bringing our ideas to life and into the lives of our users. As a Backend Engineer for the Infrastructure Engineering team, you'll play an integral part in creating the best developer experience for our product engineers. \n\nAs a member of the Data Platform team, you will be at the epicenter of an amazing company, experiencing extreme growth and solving the challenges that come with scaling rapidly. You will work closely with the business teams and other Data teams to make data better accessible and reliable while leveraging the largest-scale data processing technologies in the world. In order to succeed in this role, you should have a product mindset along with a strong vision of building data products for a massively scalable data engineering platform.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e","applyUrl":"https://jobs.lever.co/GoToGroup/449dd201-2d4d-47a0-9cd4-c7ddec91c88e/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n","additional":"<div><b>About the Team</b></div><div><br></div><div><span style=\"font-size: 10pt\">Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, and play a critical role in establishing shared systems, fostering engineering excellence, and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution, and managing risks on critical projects that involve quite a bit of cross-group collaboration.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1716821917651,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"8afd4278-a5a8-43f2-8718-2986433f2ddb","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.&nbsp;&nbsp;</li>"}],"text":"Senior Technical Program Manager - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions that are built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb","applyUrl":"https://jobs.lever.co/GoToGroup/8afd4278-a5a8-43f2-8718-2986433f2ddb/apply"},{"additional":"","additionalPlain":"","categories":{"commitment":"Permanent","department":"ODS - Regions","location":"Ho Chi Minh City","team":"-","allLocations":["Ho Chi Minh City"]},"createdAt":1717153383212,"descriptionPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","description":"<div><span style=\"font-size: 9pt\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","id":"3377f50a-d56f-42e0-acc5-b69d405a37a9","lists":[{"text":"What You Will Do","content":"<li>Identify and pursue strategic partnership opportunities that align with company goals - B2B in financial and non financial sectors</li><li>Negotiate terms and agreements with partners to drive mutual commercial successDevelop and maintain strong relationships with external partners to foster long-term collaboration</li><li>Collaborate with partners to create joint business plans aimed at achieving quarterly (QoQ) and yearly (YoY) growth targets</li><li>Monitor and analyze partnership performance, providing insights and recommendations for improvement</li><li>Work closely with internal teams, including sales, marketing, product, and finance, to ensure partnership initiatives are aligned with company objectives and obtain their successful buy in to projects and programs</li><li>Facilitate effective communication and collaboration across departments to gain buy-in for partnership strategies</li><li>Act as a liaison between partners and internal stakeholders to address any issues and optimize partnership outcomes</li><li>Be the first hand to handle issues related to the partnership and escalate the issue to the right parties (internal and external) to be solved</li><div><br></div>"},{"text":"What You Will Need ","content":"<li>Minimum Bachelor’s degree</li><li>Minimum 5 years of professional experience in partnership development or business development in companies such as start-ups, technology companies, management consulting, banking, or Fortune 500 companies</li><li>Data Analysis: Strong ability to crunch data and perform detailed data analysis. This includes interpreting complex datasets to derive actionable insights and support decision-making.</li><li>P&amp;L Understanding: Good understanding of Profit and Loss statements, with the ability to analyze financial performance and identify <a href=\"http://trends.Business\" class=\"postings-link\">trends.</a></li><li><a href=\"http://trends.Business\" class=\"postings-link\">Business</a> Acumen: Solid business acumen, enabling the development, management, and execution of business agreements and contracts. This involves a deep comprehension of business operations and strategic <a href=\"http://planning.Critical\" class=\"postings-link\">planning.</a></li><li><a href=\"http://planning.Critical\" class=\"postings-link\">Critical</a> Thinking and Problem Solving: Draws sound conclusions based upon a mixture of analysis and experience. Able to identify breakthrough solutions during tough negotiations or large-scale implementations with strategic <a href=\"http://partners.Communications\" class=\"postings-link\">partners.</a></li><li><a href=\"http://partners.Communications\" class=\"postings-link\">Communications</a> Skills: Promotes an environment of open communication. Convinces and engages others by using compelling arguments. Able to rigorously manage a portfolio of projects with strategic partners, unblock issues &amp; risks and manage expectations to ensure they are completed within target timelines and stakeholder <a href=\"http://expectations.Stakeholder\" class=\"postings-link\">expectations.</a></li><li><a href=\"http://expectations.Stakeholder\" class=\"postings-link\">Stakeholder</a> Management: Ability to develop strong, long lasting relationships with both internal and external stakeholders at all levels. Persuades and influences effectively by building support for ideas and initiatives through the effective presentation of facts and evidence. Identifies and anticipates that the partner and stakeholder needs to gain their commitment. Owns the end-to-end relationship with equivalent team and functional leads both internally and <a href=\"http://externally.B2B\" class=\"postings-link\">externally.</a></li><li><a href=\"http://externally.B2B\" class=\"postings-link\">B2B</a> Negotiation Skills: A fair, unbiased mediator and uses diplomacy and tact to diffuse tense situations comfortably</li><li>Resiliency : Demonstrates resilience &amp; composure, even in difficult or adverse circumstances. Makes and carries through unpopular or difficult decisions that are in the best interest of the team. Is able to resist the pressure to make quick decisions where due consideration is <a href=\"http://required.Abilities\" class=\"postings-link\">required.</a></li><li><a href=\"http://required.Abilities\" class=\"postings-link\">Abilities</a> to navigate and execute in a highly ambiguous environmentLocal candidates is a must</li><div><br></div>"}],"text":"Senior/Partnership Associate","country":"VN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 9pt;\">Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.</span></div><div><br></div><div><span style=\"font-size: 9pt;\">Most importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before!&nbsp;</span></div>","descriptionBodyPlain":"Are you a self starter who is not afraid to roll up your sleeves to get the work done and hit the ground running? Welcome to our partnership team in Gojek Vietnam! The Partnership team is mandated to become a source of competitive advantage in creating a sustainable, strong, and long-term alliance with partners across financial and non-financial sectors to drive our business metrics! Its main objective is to engage collaboration with new partners as well as maintaining relationships with existing partners, and continuously seek for business opportunities optimization to achieve mutual goals for both sides and improve business engagement ahead. This team will be the spearhead of the company, as a single point of contact to partners to smooth communication between parties. Partnership team is suitable for talents who have an interest in opening up connections, improving their ability to manage partnerships, sharpening business acumen and honing negotiating skills.\n\nMost importantly, we are only looking for proactive and self starters individuals to join our team! No job is too small or big for him/her, regardless if it is in or out of the job scope, we take each work assigned with pride and joy, all for creating value to Gojek! In return, we ensure that you are at the forefront of doing the most interesting partnerships in Gojek, some of which we have never done before! \n","hostedUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9","applyUrl":"https://jobs.lever.co/GoToGroup/3377f50a-d56f-42e0-acc5-b69d405a37a9/apply"},{"additionalPlain":"About the Team\n\nAs a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.\n\nOur team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>As a vital part of the Consumer Lending product team at GoTo Financial, you'll find yourself at the forefront of pioneering financial solutions. Our team is dedicated to crafting cutting-edge products that cater to the evolving needs of our customers. Joining us means not only being part of a dynamic and collaborative environment but also contributing to the innovation that defines our Consumer Lending offerings.</div><div><br></div><div>Our team values collaboration as the driving force behind our success. Open communication channels are not just encouraged but are integral to our work culture, fostering knowledge exchange and problem-solving at every step. As a member of the Consumer Lending product team, you will play a key role in shaping the future of financial technology, delivering solutions that make a meaningful impact on the lives of our users. Join us in creating the next generation of Consumer Lending experiences at GoTo Financial.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705293453270,"descriptionPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","id":"9b2d9240-3315-4b28-a7d6-73e2a097c8d7","lists":[{"text":"What You Will Do","content":"<li>Proactively monitor and troubleshoot system performance, identifying and addressing potential issues.</li><li>Collaborate with development teams to design and implement scalable and resilient system architectures.</li><li>Develop and maintain automation tools to streamline processes and enhance overall system efficiency.</li><li>Participate in incident response activities, conducting root cause analysis</li><li>Contribute to the ongoing improvement of reliability, scalability, and performance of critical infrastructure.</li><li>Work closely with cross-functional teams to align SRE efforts with broader organizational goals.</li>"},{"text":"What You Will Need","content":"<li>Solid understanding of cloud platforms such as GCP, and expertise in deploying and managing services within these environments.</li><li>In-depth knowledge of containerization technologies like Docker and orchestration tools such as Kubernetes</li><li>Proficiency in programming languages like Python, Go, or Java, with a strong software engineering foundation</li><li>Able to manage small teams and also can work as an individual contributor</li><li>Familiarity with Linux System, monitoring and logging tools to ensure comprehensive system visibility such as Prometheus, Grafana, and ELK stack</li><li>Proven track record of implementing and maintaining automation for deployment, scaling, and system orchestration.</li>"}],"text":"Site Reliability Engineer - Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.</div><div><br></div><div>In this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.</div>","descriptionBodyPlain":"About the Role\n\nAs a Site Reliability Engineer (SRE) at GoTo Financial, you will assume a crucial role in guaranteeing the smooth operation and dependability of our systems. Your responsibilities will encompass the entire software development lifecycle, with a particular emphasis on the convergence of software engineering and infrastructure operations.\n\nIn this role, you'll be at the forefront of addressing intricate challenges, ranging from optimizing system performance to architecting scalable solutions. Over the initial six months, you will be pivotal in elevating system reliability, minimizing downtime, and implementing resilient monitoring and automation tools. Your influence will extend throughout the organization as you collaborate with cross-functional teams, contributing significantly to the overall stability and performance of our critical infrastructure. Join us in shaping the future of Consumer Lending technology at GoTo Financial.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7","applyUrl":"https://jobs.lever.co/GoToGroup/9b2d9240-3315-4b28-a7d6-73e2a097c8d7/apply"},{"additionalPlain":"About the Team \n\nOur Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.\n\nHaving a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.  \n\nWe are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!\n","additional":"<div><b>About the Team </b></div><div><br></div><div>Our Social Media team known as GoSocial team is a part of the Brand Marketing team, which is divided to Social Media Strategy and Social Media Operations. As social media specialist based in Jakarta, Indonesia, we are in charge to create remarkable campaign, engaging content to spread awareness about our brand. We specialize in consulting several stakeholders in all things related social media realm, including planning and executing all social media campaign and content.</div><div><br></div><div>Having a vision to strengthen brand positioning and reputation, we act as the source of insight to guide our branding and marketing decisions. Currently, our team has been busy working on crafting social media campaign campaigns that are more focused around the inclusion of data and updated digital campaign best practices. One of our favorite campaign was Bu Sisca gantung panci.&nbsp;&nbsp;</div><div><br></div><div>We are consist of a fun, passionate, curious, agile individual who like to share shitpost, easy online game, Netflix recommendations, and of course our inexplicably amazing Spotify playlist. We do work hard and play hard, and believe it or not, we actually enjoy each other’s company!</div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Marketing","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717664713208,"descriptionPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","description":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","id":"f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","lists":[{"text":"What Will You Do ","content":"<li>Be the person in charge to create social media campaign and content; from observing trends and references, brainstorming, planning to execution (including schedule and post)</li><li>Develop social media campaigns strategies collaborate with other stakeholders&nbsp;&nbsp;</li><li>Create KOL strategy collaborate with stakeholders and third parties</li><li>Utilizing social media tools to analyze social media campaign, content, and KOL to gather insight and action plan</li><li>Collaborate with brand marketing to deliver/support marketing needs</li>"},{"text":"What Will You Need","content":"<li>At least 3-5 years related work experience from an advertising agency or start-up</li><li>Strong writing, editing, and proof-reading skills</li><li>Ability to communicate ideas clearly; a strong analytical, data-driven mindset</li><li>Broad knowledge of social media landscape, platforms, and technologies</li><li>Have interest in digital platforms, particularly in social media, and a willingness to learn more about this digital space</li><li>Strong team player with a proactive attitude and a creative/innovative mind to collaborate with multiple stakeholders</li><li>Strong analytical abilities to read, interpret, and utilize data, and to come up with actionable points for optimization and/or experimentation</li><li>Robust and detail-oriented to handle multiple works</li>"}],"text":"Social Media Specialist","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role&nbsp;</b></div><div><br></div><div>If you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.</div>","descriptionBodyPlain":"About the Role \n\nIf you’re looking to be a part of an agile, dynamic, fun, data-driven team and an opportunity to sharpen your social media marketing skills, look no further. As our Social Media Specialist, you'll take the wheel in managing one of Gojek’s social media page. You'll lay out the social media content, strategy, and execution to ensure excellent delivery. Crunching the data to gather insights for the next action improvements. Working closely with other stakeholder from brand marketing, product, corporate affair to customer services to support their need through social media realm. You'll be the social media person who responsible to any necessities and measuring the impact of these results to OKR.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3","applyUrl":"https://jobs.lever.co/GoToGroup/f9cd0695-e8a5-4381-8e9a-06091d9ed0f3/apply"},{"additionalPlain":"\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Logistics","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721898426994,"descriptionPlain":"\n","description":"<div><br></div>","id":"180b3e9e-cfb9-471d-8c30-410aef031535","lists":[{"text":"What You Will Do","content":"<li>Work closely with the Product team (i.e. PMs, Designers, Developers, and QA) right from the inception of features &amp; participate in product &amp; tech discussions, and refine the acceptance criteria and testing estimation;&nbsp;</li><li>Understand business and product requirements as related to payments and the existing service architecture;&nbsp;</li><li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team &amp; be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment &amp; work closely on the production environment, maintaining product’s&nbsp; uptime, reliability and SLOs</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby Proficient in OOP, SQL, Design Patterns</li><li>Experience with data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer  - Logistic","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><br></div>","descriptionBodyPlain":"\n","hostedUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535","applyUrl":"https://jobs.lever.co/GoToGroup/180b3e9e-cfb9-471d-8c30-410aef031535/apply"},{"additionalPlain":"About the Team \n\nMxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).\n\nCore areas that we focus on - \nDeveloper Experience and Tooling: We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.\n\nFoundation and Building Blocks: This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!\n\nApp Excellence and Insights Tooling: The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">MxT(Mobile Excellence and Tooling) is the mobile platform team at Gojek. We build small tools and standardize processes, SDKs so that product engineers can focus on Product Features. The team acts as a Center of Excellence for app performance and mobile security along with improving mobile engineers' developer experience and productivity (working in teams like GoRide, GoFood, Transport, GoPartner, etc).</span></div><div><br></div><div><b style=\"font-size: 16px\">Core areas that we focus on - </b></div><div><b style=\"font-size: 16px\">Developer Experience and Tooling: </b><span style=\"font-size: 16px\">We are a super app consisting of 22 products, each big enough to be a startup on its own. Apart from this, we have equally feature-rich driver and merchant apps. This pod is on a mission to evaluate build systems and migrate to them to get granular control on how we build our apps and the time required for the same. Reliability of CI infra for mobile apps and automated PR feedback are also the responsibilities of this team.</span></div><div><br></div><div><b style=\"font-size: 16px\">Foundation and Building Blocks:</b><span style=\"font-size: 16px\"> This team works on creating common frameworks, as in NetworkSDK, Clickstream, etc, which internal products use to build upon and code generators for boilerplates. The team also takes care of making sure the Gojek app performance is top-notch and industry-leading!</span></div><div><br></div><div><b style=\"font-size: 16px\">App Excellence and Insights Tooling: </b><span style=\"font-size: 16px\">The purpose of the App Excellence and Insights Team is to drive the success of our mobile applications by enabling teams to better monitor, maintain, and improve performance and providing data-driven insights to inform decision-making. We will identify areas for improvement, and provide recommendations to enhance app performance and ultimately user satisfaction.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697010103248,"descriptionPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","description":"<div><b style=\"font-size: 16px\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","id":"3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","lists":[{"text":"What You Will Do ","content":"<li>Work closely with product engineers across multiple Android apps, to unify the build standards</li><li>Continue pushing the limits to make sure engineers have better experience with Android Studio</li><li>Measure and Identify bottlenecks in the current build system and fix them over time</li><li>Forecast and work towards future-proofing Android platform engineering services</li><li>Resolves disputes and makes tradeoffs keeping a balance between delivery and tech</li><li>Define and drive best engineering practices in alignment with all product groups.</li>"},{"text":"What You Will Need ","content":"<li>3+ years of mobile engineering experience with Android as primary expertise</li><li>Hands-on engineer with a focus on writing easy-to-read code than over-engineering</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Well-versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>Passion for building scalable and composable systems that would last long</li><li>Participating and ability to make decisions in the architecture design review</li><li>Prioritizes and values work that is underrated but increases the predictability, quality &amp; throughput of delivery</li><li>Escalates challenges that are outside their control but affect the squad’s delivery</li><li>Prioritize work based on understanding the trade-off between quality, tech-debt, and delivery.</li>"}],"text":"Software Engineer - Android","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role </b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. </span></div><div><br></div><div><span style=\"font-size: 16px;\">Initially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.</span></div>","descriptionBodyPlain":"About the Role \n\nWe are seeking a Senior Android Engineer who has a passion for solving engineering challenges such as enhancing the build system, optimizing app performance, refining platform tools, and creating internal frameworks for reusable code. We are looking for someone with experience in collaborating within distributed teams of at least three Android developers and who enjoys advocating for innovative engineering concepts. This engineer will be part of a mobile platform team responsible for setting engineering direction and developing foundational components for over 100+ Android engineers. \n\nInitially, your focus will be improving the mobile build system currently using Gradle. Your tasks will include enhancing build performance, implementing automation to streamline the development process for product developers, and working on automation for code analysis, various test frameworks, and enhancements to the CI pipeline, among other responsibilities.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b","applyUrl":"https://jobs.lever.co/GoToGroup/3dd90bbb-893d-4f4e-bcb1-d328a1e3696b/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897603986,"descriptionPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><b><span style=\"font-size: 16px\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"96562e50-0bf7-4a14-a910-4ef63f16d451","lists":[{"text":"What You Will Do","content":"<li>Build large-scale and high-performance services to develop simple, easy-to-use products for our unique end customers</li><li>Design and develop a highly maintainable and reliable Android app</li><li>Write clean and tested code, mostly in Kotlin for Android native environment</li><li>Coordinate with other teams (Product Management, UX/Design, Backend Engineering, and Quality Engineering teams) on building and managing the Android app</li><li>Implement tech excellence in the Android development environment</li><li>Help in a constant exploration of new technology and tools</li><li>Deliver solutions that bring a positive impact to low-income communities through up-to-date software technologies</li><li>Going forward, you will have to work on flutter application as well</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of working experience in software engineering</li><li>Strong knowledge of Kotlin, Android tools and framework, and Android Studio</li><li>Good skill in unit tests. Plus points for UI tests</li><li>Experience in using app vitals and performance monitoring systems</li><li>Experience building an end-to-end system, preferably for a large user base</li><li>Strong attention to detail, particularly on software engineering fundamentals, testing methodologies, and quality</li><li>Familiarity with Android design patterns</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - Android (Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b><span style=\"font-size: 16px;\">About the Role </span></b></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the Role \n\nAs a GoPay -Android Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451","applyUrl":"https://jobs.lever.co/GoToGroup/96562e50-0bf7-4a14-a910-4ef63f16d451/apply"},{"additionalPlain":"About the Team\n\nThe Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).\n\nOne of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.\n\nOff hours, you’d probably find us hang out, dinner together or playing games\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>The Resolution Experience team is a key function for our customer care vision of providing the best in class customer service agents by reducing agent defect rate, providing best service, and faster resolution time. Our Agent Experience team, a part of the larger CareTech team is a group of Salesforce engineers and product engineers based in Jakarta. We are in charge of creating improvement on agent experience by making the Ticketing System a better place for them (less defect), reducing friction of agents when handling customer’s tickets for faster resolution (shorter resolution time) and removing dependency on the team to support Gojek initiatives (decentralize work).</div><div><br></div><div>One of the biggest challenges this team has is to improve our customer service agents in terms of making their work easier with the best quality ticket resolution delivered to our loyal customers.</div><div><br></div><div>Off hours, you’d probably find us hang out, dinner together or playing games</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Consumer Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1697610584742,"descriptionPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","id":"cd554abc-dc06-4177-be50-ccbc638fd6d9","lists":[{"text":"What You Will Do","content":"<li>Work closely with team lead to deliver product features that enable efficient handling of queries for our internal users (customer service agents) and complaints raised by external users (customer, driver, and merchant)</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems</li><li>Write code that’s clear, concise, performant, tested and easily understood by others</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Writing technical documents and providing technical training for end users if necessary</li><div><br></div>"},{"text":"What You Will Need","content":"<li>At least 2-3+ years of hands-on experience in designing, developing, testing, and deploying applications on Go-Lang, Clojure, Java, Ruby, or OOPL large-scale applications</li><li>In-depth experience&nbsp;of at least one programming language and framework, deep understanding of SQL databases, Linux, Kafka, Redis, and RabbitMQ</li><li>Proficient in OOP, SQL, Design Patterns Data modeling experience in Relational databases</li><li>Well versed with Agile methodologies, TDD and Test Engineering and Automation</li><li>Ability to plan, prioritize, estimate and execute releases with a good degree of predictability</li><li>Ability to scope, review and refine user stories for technical completeness and to alleviate risks</li>"}],"text":"Software Engineer - Customer Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team.&nbsp;</div><div><br></div>","descriptionBodyPlain":"About the Role\n\nAs a backend engineer in the Resolution Experience team, you’ll contribute to help the Gojek Care team to achieve the best Customer Service in class. You will take the wheel in overseeing Backend Engineering for the team - designing and developing highly scalable, reliable, and maintainable solutions. You will establish and evangelize the best engineering practices for your team to follow, and improve operational excellence and SLA’s of the microservices owned by the team. \n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9","applyUrl":"https://jobs.lever.co/GoToGroup/cd554abc-dc06-4177-be50-ccbc638fd6d9/apply"},{"additionalPlain":"About the Team\n\nConsumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.\n\nWe are responsible for building and growing the customers and payments made through  GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia. \n\nAs part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.\n","additional":"<div><span style=\"font-size: 16px\"><b>About the Team</b></span></div><div><br></div><div><span style=\"font-size: 16px\">Consumer Payments is part of GoTo’s financial services arm. Our team works to provide responsible and sustainable financial services to our users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality life, both in the present as well as in the long term.</span></div><div><br></div><div><span style=\"font-size: 16px\">We are responsible for building and growing the customers and payments made through&nbsp; GoPay . GoPay is South East Asia’s fastest-growing consumer payments and financial services app and serves tens of millions registered users on a variety of payment avenues, providing the most convenient payment methods in South East Asia.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 16px\">As part of the Payment Core team, you will be responsible for delivering essential financial solutions to help grow GoPay users. Beside the fully homemade features, the team is also working in-depth integration with bank partners.</span></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Payment Core","allLocations":["Jakarta"]},"createdAt":1721897318094,"descriptionPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","description":"<div><span style=\"font-size: 16px\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","id":"4439eb62-6f08-444b-946d-1dff07d7d0d3","lists":[{"text":"What You Will Do","content":"<li>Working on mobile applications iOS and going forward you will work on flutter application</li><li>Attend daily standup meetings, do sprint planning/backlog reviews, communicate project/development status to internal and external teams in a timely fashion</li><li>Participating in the design review process, seeking and providing constructive criticism</li><li>Improving code structure and architecture in service of testability and maintainability</li><li>Mentoring other engineers on an individual basis and ensuring that their team has strong sets of documentations of how their design and architecture evolves over time</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>2-4 years of experience with iOS development</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in Swift programming, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Understanding of iOS Apps architecture and implementation</li><li>Ability to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular third party libraries for networking, async, image loading etc</li><li>Good analytical and problem solving skills</li><li>Working knowledge of Flutter is a plus, but not required</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer - iOS ( Consumer Payments)","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 16px;\"><b>About the the Role</b></span></div><div><br></div><div><span style=\"font-size: 16px;\">As a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.</span></div>","descriptionBodyPlain":"About the the Role\n\nAs a GoPay - iOS Engineer, you are expected to build, release and maintain a large scale application. You will also be responsible for working knowledge of the general mobile landscape, trends, and emerging technologies. You will take a key role on our team, collaborate with a close-knit product engineering team to deliver great products to our customers! The team is built on high collaboration, trust, and self-management.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3","applyUrl":"https://jobs.lever.co/GoToGroup/4439eb62-6f08-444b-946d-1dff07d7d0d3/apply"},{"additionalPlain":"About the Team\n\nGoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">GoFood is a vertical in Gojek that helps customers to order food online from their choice of restaurants using customer apps and web platforms. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Food Ordering journey smooth for our customers.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Food","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1716980506841,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","id":"930cfb6b-99e3-4334-bc10-3fac18f8eff0","lists":[{"text":"What You Will Do","content":"<li>Design, build and improve the mobile experiences for one of the world's fastest growing mobile apps</li><li>Partner with the product management team to define and execute the feature roadmap</li><li>Coordinate with cross functional teams (Backend, DevOps, Design etc.) on planning and execution</li><li>Proactively manage stakeholders communication related to deliverables, risks, changes and dependencies</li><li>Helping out in onboarding process by sharing contexts and pairing with new member of the team</li><li>Start mentoring or guiding SE1</li><li>Communicate, collaborate and work effectively across cross functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years relevant software development experience through internship stint and/or college projects</li><li>Proficient in Kotlin programming, Java and the Android APIs. </li><li>Strong knowledge in Android Apps architecture and implementationAbility to write model code for functional and nonfunctional requirements and help improve the code quality standard across the team</li><li>Working experience with popular libraries for networking, async, image loading etc.</li><li>Well-versed with Agile methodologies, TDD and Test Engineering and Automation.</li>"}],"text":"Software Engineer (Android) - Gofood","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.</span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for the Android Engineering Team at Gojek. Working within the GoFood team, you'll focus on enhancing app UI and performance, always keeping the customer experience front and center.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0","applyUrl":"https://jobs.lever.co/GoToGroup/930cfb6b-99e3-4334-bc10-3fac18f8eff0/apply"},{"additionalPlain":"About the Team\n\nMerchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.\n\nOur team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Merchant Lending is part of GoTo Financial’s financial services unit. Our team works to provide responsible and sustainable financial services to our merchant partners. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term.</div><div><br></div><div>Our team’s mission is to empower our users to realize their dreams through responsible lending. GoModal, our flagship product, currently helps many merchant partners to increase the size, scale, and quality of their operations. We’re planning on growing aggressively in 2024 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though our team members are from Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock any barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take the time to learn about one another outside the office.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Merchant Services","location":"Jakarta","team":"Merchant Lending","allLocations":["Jakarta"]},"createdAt":1721735169268,"descriptionPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","description":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","id":"dab778da-b4eb-4e7e-bc8e-997af7210d52","lists":[{"text":"What You Will Do","content":"<li>Develop and maintain user-facing features, translating designs and requirements into well-designed, testable and efficient code</li><li>Collaborate with other team members and stakeholders to deliver high-quality software solutions</li><li>Troubleshooting and debugging to optimize performance.</li><li>Be proactive, ask questions, and be an active member of the team striving towards improving the merchant experience&nbsp;</li><li>Learn new technologies to keep yourself updated and brainstorm with the managers about using the new technologies in day-to-day problem-solving</li>"},{"text":"What You Will Need","content":"<li>Degree/Diploma in Computer Science, Engineering, or related field.</li><li>2+ years of experience in developing using Java</li><li>Understand programming practices such as separation of concerns, unit testing, and writing self-documenting code</li><li>Familiarity with mainstream frameworks like Spring, Spring Boot, and Linux operating systems, understanding of database principles, and proficiency in using databases like MySQL or PostgreSQL.</li><li>Familiarity with front-end related technologies and concepts such as Javascript/Typescript, CSS, HTML, DOM, network protocol, and mainstream front-end frameworks</li><li>Have good communication skills and teamwork spirit, and be able to collaborate effectively with other developers.</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (Back End) - Merchant Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>As a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs &amp; requirements.</div>","descriptionBodyPlain":"About the Role\n\nAs a Software Engineer (Back End) of the Merchant Lending team, you will be part of a dedicated team that will drive financial inclusion for SMEs in Indonesia. Being a part of a self-driven team, you will have the opportunity to work with top-class engineering teams which will help you learn and grow. You will be contributing to the efforts of launching and enhancing multiple lending products catering to the merchant's needs & requirements.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52","applyUrl":"https://jobs.lever.co/GoToGroup/dab778da-b4eb-4e7e-bc8e-997af7210d52/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713521223842,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"331177df-4294-4bc1-93a4-6459ff18ef97","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97","applyUrl":"https://jobs.lever.co/GoToGroup/331177df-4294-4bc1-93a4-6459ff18ef97/apply"},{"additionalPlain":"About the Team \n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\n\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team </b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><br></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1721899384459,"descriptionPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","description":"<div><b style=\"font-size: 16px\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","id":"c0e92e19-ce60-4cfc-a58b-553f17452483","lists":[{"text":"What You Will Do","content":"<li>Own product development on functional and non-functional requirements, OKRs, and improvements to code quality across the team</li><li>Design and develop low latency, high throughput systems with minimal guidance</li><li>Be responsible for ensuring the quality and timeliness of deliverables for the team</li><li>Be a self-learner when it comes to technology and work with the team to collaborate on the engineering initiatives as the products go through the evolution cycle</li><li>Own the entire lifecycle of feature development, test, deployment, fixes and improvements</li><li>Work with tech leads, product managers and other stakeholders to continuously work towards progressing on the group’s and organization’s goals</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li>"},{"text":"What You Will Need","content":"<li>At least 2 years of experience in designing, developing, testing and deploying applications with Golang/Java/Ruby. Proficient in OOP, SQL, Design Patterns</li><li>Experience with functional programming, data modeling experience in Relational and/or NoSQL databases is a plus&nbsp;</li><li>Well-versed with agile methodologies</li><li>Hands on knowledge of unit testing methodologies and frameworks</li><li>Experience troubleshooting server performance - memory issues, GC tuning, resource leaks</li><li>Experience working in technologies like Kafka, RabbitMQ, Postgres, MySql, Redis, Aerospike, or similar</li>"}],"text":"Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role&nbsp;</b></div><div><br></div><div><span style=\"font-size: 16px;\">At Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.</span></div><div><span style=\"font-size: 16px;\">The person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests.&nbsp;</span></div>","descriptionBodyPlain":"About the Role \n\nAt Gojek, engineering is central to everything we do to bring cheer to the lives of millions. In this role, you will be part of Gojek’s transport engineering team, building some of the most critical products for our consumers. As a Software Engineer in Gojek, you will be responsible for building systems and products across the various areas of business for Gojek Transport. Your ownership, drive, and passion would help provide for a world-class user experience and stability of Transport products for mobility or people and packages.\nThe person should be passionate about maintaining a clean and maintainable codebase. Your primary focus will be the development of distributed systems and services that are fault-tolerant, highly performant and responsive to high throughput client requests. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483","applyUrl":"https://jobs.lever.co/GoToGroup/c0e92e19-ce60-4cfc-a58b-553f17452483/apply"},{"additionalPlain":"About the Team\n\nConsumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.\n\nThough we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Consumer Lending is part of GoFin, Gojek's financial services arm. Our team works to provide responsible and sustainable financial services to Gojek users. We operate with the fundamental belief that financial inclusion can unlock the doors to a better quality of life, both in the present as well as in the long term. Our team’s mission is to empower our users to realize their dreams through responsible lending. GoPayLater, our flagship product, currently helps millions of users afford their everyday needs while budgeting for the future - through good times and tough times. We’re planning on growing aggressively in 2021 and beyond by tapping into and expanding our services into new platforms and partners.</div><div><br></div><div>Though we’re spread across Indonesia, India, and Singapore, we all enjoy collaborative iterative development with fast feedback cycles and prefer making pragmatic technical decisions despite working under a myriad of business and regulatory constraints. We work in a highly supportive environment where we never hesitate to help each other out, unblock all barriers, and have fun along the way. We love to take advantage of the fact that our members come from such a wide variety of cultures and backgrounds and take time to learn from and about one another on our informal Zoom hangouts.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Singapore","team":"-","allLocations":["Singapore"]},"createdAt":1714016329286,"descriptionPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","description":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","id":"88358de8-e37b-4bd6-9afe-359eea3128b9","lists":[{"text":"What You Will Do","content":"<li>Own feature development from end-to-end, constantly pair with junior engineers, and improve them.</li><li>Write code that's clear, concise, performant, tested, and easy to understand by other teams and engineers.</li><li>Contribute to the design and development of highly scalable, available, reliable, secure, and fault-tolerant services.</li><li>Try improving engineering standards, tooling, and processes after understanding our needs without jumping straight into standard practices.</li><li>Deep dive and debug production issues across services and levels of the stack when needed.</li><li>Coordinate and communicate with different internal/external teams daily—stay in close communication with the product manager and team lead to execute the feature roadmap efficiently.</li>"},{"text":"What You Will Need","content":"<li>Passion for software development</li><li>At least 3 years of relevant software development experience with consumer/merchant products; hands-on experience in developing, testing, and deploying applications</li><li>Ability to learn or use Java, Kotlin, and JS, proficiency in at least one of them</li><li>Understanding of concepts like HTTP/GRPC, idempotency, concurrency, database consistency and transactionality, asynchronous programming, fault tolerance and monitoring, performance, feature flags, and backward compatibility&nbsp;</li><li>Understanding of a mobile application’s interaction with the back-end and other systems</li><li>Deep understanding of relational databases; ability to design performant, easy-to-understand architectures, and know-how for applying changes with no downtime to production systems</li><li>Experience with monitoring tools and a good understanding of their concepts</li><li>Have some experience with infrastructure-related tools and concepts such as Kubernetes, Kafka, RDS, AWS, GCP</li>"}],"text":"Software Engineer (Full Stack) - BNPL","country":"SG","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div><span style=\"font-size: 10pt;\">If you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.</span></div>","descriptionBodyPlain":"About the Role\n\nIf you're looking to hone in on your engineering abilities and work on mission-critical high scalability distributed systems, this may be the job for you. As a Senior Software Engineer, your contributions will be crucial for the development of financial products. You will help shape the future of our Consumer Lending products, and more importantly, help millions of users meet their financial needs responsibly.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9","applyUrl":"https://jobs.lever.co/GoToGroup/88358de8-e37b-4bd6-9afe-359eea3128b9/apply"},{"additionalPlain":" About the team\n\nOur Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\nOur team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).\nWe, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div>&nbsp;<span style=\"font-size: 16px\">About the team</span></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers and product managers spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><span style=\"font-size: 16px\">Our team recently figured out that our existing third-party SDK for in-app live tracking of vehicles was not operating as smoothly as we had expected. So, guess what? We fixed this by building our own live tracking SDK - Navic. Right now, our team has been busy working on projects that aim to effectively grow our user base in the region (and beyond!).</span></div><div><span style=\"font-size: 16px\">We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or hanging out with each other. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721899689491,"descriptionPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","id":"89a62415-b145-4593-ac20-b82ec0ccfacb","lists":[{"text":"What You Will Do","content":"<li>Solve technical problems and build the next generation of products for our consumers</li><li>Spike new technologies and find a viable way to improve customers experience</li><li>Improve the testability and maintainability of the code</li><li>Build reusable iOS software components for interfacing with multiple applications</li><li>Improve and stabilize IOS sdks used by number of internal and external clients</li><li>Formulate and create clear and efficient technical documentation</li><li>Write code that is clear, concise, performant, tested, and easily understood by others</li><li>Work with backend, UX teams, both within and outside the team to build robust, well-designed interfaces</li>"},{"text":"What You Will Need","content":"<li>At Least 2 years of full-time iOS engineering experience</li><li>Experience developing, maintaining, and innovating large scale, consumer mobile application</li><li>Predictability and balance of product delivery speed and quality</li><li>In-depth knowledge of iOS app architecture and implementation including proficiency in <b>Swift programming</b>, Cocoa, Xcode and the iOS SDK</li><li>Strong problem solving and analytical skills</li><li>Command over the technology ecosystem and ability to learn and ramp up on the latest trends</li><li>Working experience with popular libraries for networking, async, image loading, etc</li><li>Ability to write model code for functional and non-functional requirements and help improve the code quality standard across the team</li><li>Experience and knowledge of writing testable and high-quality code</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Software Engineer (iOS) - Transport","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">In this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users.&nbsp;</span></div>","descriptionBodyPlain":"About the Role\n\nIn this role, you will play a key role in the growth of the transport product lines at Gojek. You will be exposed to complexities that will challenge your problem solving skills and will learn how to build and operate high throughput systems. You will be responsible for designing, developing and deploying iOS applications/SDKs for some of the most critical and technically complex offerings that Gojek has. Your ownership, drive and passion would help provide for a world-class user experience and stability of our iOS products. You will be a key part of the team and will work with some of the brightest minds in the industry across design, product and engineering in solving meaningful real-world problems impacting the lives of millions of users. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb","applyUrl":"https://jobs.lever.co/GoToGroup/89a62415-b145-4593-ac20-b82ec0ccfacb/apply"},{"additionalPlain":"About the Team\n\nOur GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.\n\nOur service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.\n\nAs a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Our GoPay team consists of 200+ zealous folk based in Jakarta and Bangalore. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. We run and oversee one of Southeast Asia's largest e-money wallet platforms and Indonesia's leading digital payments provider.</div><div><br></div><div>Our service is now accepted by over 300,000 online and offline merchants in Indonesia alone, with our ecosystem processing US$3.6 billion of annualized Gross Transaction Value. But, the growth of Payments does not stop here. We are hungry for more. We intend to become the largest payment and financial services group in Southeast Asia. It's our job to ensure that this number grows, and more importantly, that anyone utilizing our platform is given the most seamless payment experience possible. How does one achieve this, you may ask? By collaborating diligently with our users to understand the daily obstacles they face in the payment arena, and then crafting our products and services to aid these issues.</div><div><br></div><div>As a team, we’re concerned not only with the growth of the company but each other’s personal and professional growth, too. Along with a common drive to jump over technical barriers and provide sustainable solutions, our team bonds over our shared love for tea, movies, and TV shows (Netflix, anyone?😜).</div>","categories":{"commitment":"Internship","department":"FinTech - Merchant Services","location":"Jakarta","team":"Online Merchants","allLocations":["Jakarta"]},"createdAt":1719909295384,"descriptionPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","description":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","id":"1a190954-9482-4953-a750-f2ae33a50003","lists":[{"text":"What You Will Do","content":"<li>Develop and Test: Write, test, and maintain software across our platforms, ensuring robustness and scalability.</li><li>Collaborate: Work closely with senior engineers and cross-functional teams including Backend, Frontend, Mobile, and QA to design and execute solutions.</li><li>Learn and Grow: Receive mentorship from senior engineers, enhancing your understanding of software development processes and best practices.</li><li>Contribute: Play a key role in the development and optimization of new features and systems within Midtrans.</li>"},{"text":"What You Will Need","content":"<li>Currently enrolled in or recently graduated with a degree in Computer Science, Software Engineering, or a related field.</li><li>Strong foundational knowledge in at least one programming language (Java, Python, JavaScript, etc.).</li><li>Understanding of basic software development concepts and methodologies.</li><li>Familiarity with version control systems, preferably Git.</li><li>Problem-Solving: Ability to think critically and solve complex problems.</li><li>Communication: Excellent verbal and written communication skills.</li><li>Teamwork: Eagerness to work within a team-oriented environment.</li><li>Adaptability: Openness to learning new technologies and methodologies.</li>"}],"text":"Software Engineer Intern - Online Merchants","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Join our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.</div><div><br></div><div>Joining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!</div>","descriptionBodyPlain":"About the Role\n\nJoin our dynamic engineering team as a Software Engineering Intern! This role is part of the Senior Engineer - Intern Pairing Program, where you'll be paired with a seasoned senior engineer to gain hands-on experience and contribute to a variety of projects across our core services. You will be immersed in an environment that values innovation, efficiency, and continuous development, working on real-world problems and helping us enhance our payment gateway solutions.\n\nJoining us means you'll receive direct mentorship from experienced engineers, providing a unique learning opportunity to enhance your skills. You'll have the chance to make a real impact by contributing directly to projects that affect millions of users. Our inclusive and innovative culture not only encourages personal and professional growth but also offers ample leadership opportunities. Be part of a team where your contributions matter, and your potential is recognized and nurtured!\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003","applyUrl":"https://jobs.lever.co/GoToGroup/1a190954-9482-4953-a750-f2ae33a50003/apply"},{"additionalPlain":"About the Team\n\nThe Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.\n\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">The Insurance Platform team thrives on a culture of collaboration, continuous learning, and innovation. We have built features like Accidental Insurance, CrackScreen Insurance, and Health Insurance, creating more than 1 million policies each day. We are passionate about delivering high-quality insurance service experiences and constantly strive to improve our processes and products. Working within our team means being part of a supportive environment where every member's input is valued, and professional growth is encouraged. We focus on open communication, constructive feedback, and pushing the boundaries of what we can achieve together. As a team, we celebrate successes, learn from challenges, and work towards our common goal of excellence in every release.</span></div><div><br></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Payments","location":"Jakarta","team":"Money Management","allLocations":["Jakarta"]},"createdAt":1721305380078,"descriptionPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","id":"75c0d634-b28a-4f10-8f5a-efacb32b6444","lists":[{"text":"What You Will Do","content":"<li>Collaborate with product engineers to unify and optimize build standards across Android apps</li><li>Enhance build performance and streamline development processes</li><li>Identify and resolve bottlenecks in the current build system.Forecast and future-proof Android platform engineering services</li><li>Implement best engineering practices and ensure adherence across product groups</li><li>Conduct thorough code reviews and provide constructive feedback</li><li>Mentor junior engineers and support their professional growth</li><li>Participate in architectural design reviews and contribute to technical decision-making</li>"},{"text":"What You Will Need","content":"<li>5+ years of mobile engineering experience with Android as primary expertise</li><li>Proficiency in writing clear, concise, and maintainable code</li><li>Experience with collaborating on projects involving multiple teams</li><li>Strong understanding of mobile app architecture, testing, and performance optimization</li><li>Passion for building scalable and reusable systems</li><li>Ability to make informed decisions in architectural design reviews</li><li>Experience with build systems and CI/CD pipelines</li><li>Familiarity with Flutter or a willingness to learn it</li>"}],"salaryDescription":"<div><br></div>","salaryDescriptionPlain":"\n","text":"Sr. Software Engineer (Android) - Insurance","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.</span></div>","descriptionBodyPlain":"About the Role\n\nWe are seeking an experienced Android Engineer with a passion for solving complex engineering challenges and enhancing mobile app performance. You will be a key player in our Insurance Platform team, leading the development of new features and improving existing ones. Over the first six months, you will focus on enhancing and building new products inside Gopay App, collaborating across multiple teams to ensure a seamless development process, and driving best practices in mobile engineering. Your contributions will directly impact the quality and reliability of our insurance services, supporting over a million policies created daily.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444","applyUrl":"https://jobs.lever.co/GoToGroup/75c0d634-b28a-4f10-8f5a-efacb32b6444/apply"},{"additionalPlain":"About the Team\n\nOur Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.\n\nTransport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)  using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">Our Transport team is a big family of 100+ members made up of engineers, product managers, business strategy planners spread out across Jakarta, Bangalore, Singapore, and Vietnam. We run Southeast Asia’s leading and fastest-growing ride-hailing business and oversee all things related to our riders and driver-partners' needs in daily transport and work daily to create solutions to these issues. It’s our job to ensure that our Transport services run seamlessly from the inside out.</span></div><div><br></div><div><span style=\"font-size: 16px\">Transport Booking-experience is a vertical in Gojek that helps customers to order different modes of transport online from their choice of available transport products like (two-wheeler, car, premium, xl etc)&nbsp; using the Gojek customer app. On a day to day basis teams are involved in brainstorming and developing solutions for different optimisations that bring efficiency in the ecosystem making the Transport Ordering journey smooth for our customers. You will be working on the next set of features that are set to change or enhance the day-to-day experience of customers booking a ride from A to B. We, the Transporters, know how to work hard and play hard. When we aren’t busy working, you’d probably find us playing online games like Among Us and Sketchful, or catching up with each other on our virtual hangouts. We work as a team to get our job done well, and genuinely enjoy each other's company.</span></div>","categories":{"commitment":"Permanent","department":"ODS - Transport","location":"Bengaluru","team":"-","allLocations":["Bengaluru"]},"createdAt":1717676182978,"descriptionPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","id":"22ac4805-bcbe-4698-9e51-cb25754ac244","lists":[{"text":"What You Will Do","content":"<li>Work cross-functionally with product, design, backend and other teams across regions and independently ship world-class products and features with minimal guidance</li><li>Design and develop highly scalable, available, reliable, secure and fault-tolerant systems with minimal guidance for one of the world’s fastest-growing companies in travel</li><li>Write code that is clear, concise, performant, tested and easily understood by others</li><li>Actively mentor SE/ASEs&nbsp; in the team</li><li>Translate business requirements into scalable and extensible design</li><li>Communicate, collaborate and work effectively across cross-functional teams in a global environment</li><li>Build and manage automated build/test/deployment environments</li><li>Improve engineering standards, tooling and processes</li>"},{"text":"What You Will Need","content":"<li>At least 4 years of hands-on experience in developing, testing and deploying large scale applications</li><li>Have expertise in at least one of Go or Java</li><li>In-depth knowledge of unit testing methodologies and frameworks</li><li>Ability to understand and implement Continuous Integration and Continuous Delivery</li><li>Well versed with Agile methodologies, Test Engineering and Automation</li><li>Proficient in troubleshooting server performance - memory issues, GC tuning, resource leaks etc</li><li>Excellent understanding of interactive application development paradigm, memory management, performance/resource optimisations, database interactions, network programming, concurrency and multithreading, fault tolerance, monitoring, security and operability of systems</li><li>Ability to estimate and execute releases with a good degree of predictability</li>"}],"text":"Sr. Software Engineer (Backend) - Transport","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">Roll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. </span></div>","descriptionBodyPlain":"About the Role\n\nRoll up your sleeves and climb on board if you’re ready to be our next Software Engineer. In this role, you will be an integral player for Backend Engineering at Gojek - designing and developing highly scalable, reliable, maintainable and fault tolerant systems which powers one of South-East Asia’s biggest ride hailing and mobility experiences . As a member of the core Transport Booking experience team you will be working with other peers to power the core booking experience of transport orders on Gojek. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244","applyUrl":"https://jobs.lever.co/GoToGroup/22ac4805-bcbe-4698-9e51-cb25754ac244/apply"},{"additionalPlain":"About the Team\n\nWe are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks\n\nYou get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation. \n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 16px\">About the Team</b></div><div><br></div><div><span style=\"font-size: 16px\">We are the heart of Gojek, the group that owns, improves, and manages Gojek's engineering productivity, reliability, and observability across the board. We are responsible for the pillars of technology, science, and strategy across engineering, powering over 500+ microservices at Gojek. We leverage cutting edge technology in cloud computing managing real-time high throughput systems with a wide range of programming stacks</span></div><div><br></div><div><span style=\"font-size: 16px\">You get to work with an insanely driven and proud team of engineers who deliver fundamental functionality to enable multiple product groups at Gojek to deal with scenarios at a really interesting combination of scale and complexity. Go-Jek has grown exponentially in the past couple of years, resulting in an explosive growth of tech stack and infrastructure. Our DevOps team is focused on the task of heavy lifting and supporting the engineering platform in terms of scalability, efficiency and automation.&nbsp;</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Technology","location":"Bengaluru","team":"-","allLocations":["Bengaluru","Jakarta"]},"createdAt":1713436041495,"descriptionPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","description":"<div><b style=\"font-size: 16px\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","id":"e2bbb29c-85ef-4db2-9ea7-93af9101b634","lists":[{"text":"What You Will Do","content":"<li>Automate mechanism to make sure app performance adheres to the standards set internally</li><li>Building tools that would alleviate mobile engineer's development experience and productivity&nbsp;</li><li>Build dashboard and alerting system around mobile app performance (using tools like Firebase, Instabug, etc)</li><li>Foster a development culture that focuses on the quality of delivery</li><li>Creating and maintaining SDKs like networking, logging, etc. These sdk’s are responsible for providing common solutions to products across all iOS mobile teams</li><li>Continuously discover, evaluate, and implement new technologies to maximize development efficiency</li><li>Create excellent, clear, and insightful documentation ex: guidelines, best practices, how-to, FAQs etc</li>"},{"text":"What You Will Need","content":"<li>Atleast 3+ years of mobile engineering experience with iOS as primary expertise</li><li>Should have worked on projects (preferably Frameworks/SDKs) that involve collaborating with multiple teams&nbsp;</li><li>Ability to can take (or pitch) technical decisions, own it and raise impediments early if needed</li><li>You are very well versed in architectural approaches, testing, and performance when it comes to building mobile apps</li><li>You have a passion for building scalable and composable systems that would last long</li><li>You are a hands-on engineer with a focus on writing easy to read code than over-engineering</li><li>You are a great communicator who can express your ideas clearly and build consensus to push technical agendas</li>"}],"text":"Sr. Software Engineer (iOS) - Engineering Platform","country":"IN","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 16px;\">About the Role</b></div><div><br></div><div><span style=\"font-size: 16px;\">We are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.</span></div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nWe are looking for a Senior iOS Engineer who loves to tackle engineering problems like, app performance, platform tooling, and building internal frameworks for code reuse. One who has worked on a large codebase in distributed teams with more than 3 iOS devs and enjoys evangelizing engineering ideas. The engineer would be working on the mobile platform team that is responsible for providing engineering direction and building blocks to more than 80+ iOS engineers.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634","applyUrl":"https://jobs.lever.co/GoToGroup/e2bbb29c-85ef-4db2-9ea7-93af9101b634/apply"},{"additionalPlain":"About the Team\nWhat is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.\n\nWe prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.\n\nUnsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table. \n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About the Team</b></div><div><span style=\"font-size: 16px\">What is Creative Labs? A bunch of creative geeks? A cult of mad scientists? The truth is… we’re a combination of both! As part of the Gojek Marketing Team, we’re made up of Project Managers, Account Managers, Strategists, Copywriters, Graphic Designers, and Art Directors who work together to turn business objectives into creative outputs. Based in Jakarta, Indonesia, our main focus is to create the right communication - copy, visuals, medium included - to heighten user acquisition. We want to convey to as many people as possible the value of Gojek’s products in solving everyday problems - from food, transport, to payments - and easing our daily routines.</span></div><div><br></div><div><span style=\"font-size: 16px\">We prioritize an in-depth understanding of our target audience and craft all of our creative campaigns based on these findings. Some of these past campaigns include Foodiskon, Ramadan, “It’s OK To Be Lebay”, and J3K. Currently, our team has been working on a lot of innovation and promotional campaigns, which will help Gojek maintain our leadership in the market.</span></div><div><br></div><div><span style=\"font-size: 16px\">Unsurprisingly, our creative family comprises music enthusiasts, coffee connoisseurs, and movie buffs. Regardless of whether we’re working from home or the office, one of our favorite aspects of being a part of the Creative Labs fam is that we get to dress however we want! After all, fashion is a creative mode of expression 😎 If this sounds like a team you’d like to be a part of, we’ll save you a spot at the table.&nbsp;</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Shared Service, Customer Relationship Management","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1717559195275,"descriptionPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","id":"8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","lists":[{"text":"What You Will Do","content":"<li>Help provide clarity and direction for marketing campaigns or initiatives</li><li>To become the bridge between the Creatives and the marketing, media, social, design, product and research team</li><li>Always bringing the consumer perspective into the creative process in Gojek by simply staying in touch with society and the trends that are changing it</li>"},{"text":"What You Will Need","content":"<li>You have at least 5 years of strategy experience in an agency or related environment</li><li>Ability to deliver a clear, insight-based strategic recommendation in the form of a written brief</li><li>Ability to support Creatives and Designers&nbsp; with relevant stimulus, routes, or advice</li><li>Ability to visualize simple customer journeys in clear &amp; compelling ways</li>"}],"text":"Strategic Planner - Creative Labs - #10088","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">The Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.</span></div><div><br></div><div><span style=\"font-size: 16px;\">You will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.</span></div><div><br></div><div><span style=\"font-size: 16px;\">That’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.</span></div>","descriptionBodyPlain":"About The Role\nThe Strategic Planner in Gojek Creative Labs is perfect for someone who is driven by curiosity about people, culture, and different ways of working. If you come from an agency background, this role will show you how the role of a strategist is becoming more important, dynamic, and exciting.\n\nYou will be exposed to how brand strategy can influence not only communication but also design, product experience, and also operations.\n\nThat’s why we are looking for people who are collaborative, resourceful, and able to stand up for your ideas in an environment that is always stimulating and never dull.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66","applyUrl":"https://jobs.lever.co/GoToGroup/8c6c6929-a2c4-4ef4-b93f-1c394ef3fe66/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1713867338946,"description":"","descriptionPlain":"","id":"afb5bc40-aa4f-4837-a2d9-7d38eade2599","lists":[{"text":"What will you do","content":"<li>Assume ownership of key performance indicators (KPIs) driving revenue and profitability for Consumer Lending <a href=\"http://business.Develop\" class=\"postings-link\">business.</a></li><li><a href=\"http://business.Develop\" class=\"postings-link\">Develop</a> comprehensive strategies and roadmaps to achieve growth objectives through a combination of <a href=\"http://initiatives.Identify\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Identify\" class=\"postings-link\">Identify</a> growth opportunities within the consumer lending business by analyzing business data, transactional data, customer activity within platforms, and leveraging customer <a href=\"http://insights.Lead\" class=\"postings-link\">insights.</a></li><li><a href=\"http://insights.Lead\" class=\"postings-link\">Lead</a> the prioritization process, strategizing, and focusing on solutions aimed at addressing user needs and enhancing user <a href=\"http://experience.Validate\" class=\"postings-link\">experience.</a></li><li><a href=\"http://experience.Validate\" class=\"postings-link\">Validate</a> business strategies and hypotheses through rigorous experimentation and statistical <a href=\"http://methodologies.Present\" class=\"postings-link\">methodologies.</a></li><li><a href=\"http://methodologies.Present\" class=\"postings-link\">Present</a> findings and insights to senior management to inform strategic decision-making regarding feature prioritization and impact <a href=\"http://analysis.Cultivate\" class=\"postings-link\">analysis. </a></li><li><a href=\"http://analysis.Cultivate\" class=\"postings-link\">Cultivate</a> and manage partnerships with external stakeholders.</li>"},{"text":"What will you need","content":"<li>BS/MS in Business, Engineering, Computer Science, Math, Economics, Statistics, or <a href=\"http://equivalent.8-10\" class=\"postings-link\">equivalent.</a></li><li><a href=\"http://equivalent.8-10\" class=\"postings-link\">8-10</a> years of working experience with strong business <a href=\"http://acumen.End\" class=\"postings-link\">acumen.</a></li><li><a href=\"http://acumen.End\" class=\"postings-link\">End</a> to end problem-solving mindset that can work in increments and <a href=\"http://exponents.Strong\" class=\"postings-link\">exponents.</a></li><li><a href=\"http://exponents.Strong\" class=\"postings-link\">Strong</a> project management skills to manage complex projects, also can manage and prioritize multiple internal and external <a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Proficiency\" class=\"postings-link\">Proficiency</a> in multiple analytic and database tools common within a marketing organization (e.g., Clevertap, Tableau, etc.) with good knowledge of SQL and experimentation processHustle is essential, moving quickly and executing to allow for continual iteration is a core competency of the teamExperience in a financial services and technology companies is preferred.</li>"}],"text":"Strategy Senior Manager, Consumer Lending","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"","descriptionBodyPlain":"","hostedUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599","applyUrl":"https://jobs.lever.co/GoToGroup/afb5bc40-aa4f-4837-a2d9-7d38eade2599/apply"},{"additionalPlain":"Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,  and then design personalized and impactful ad solutions for them. \n\nOur main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).\n\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><span style=\"font-size: 10pt\">Our GoFood team consists of 100+ zealous folks from various disciplines. As Nasi Goreng is to the people of Indonesia, we are to Gojek: providing the nourishment to sustain our business from the inside out. Our main responsibility is to cater to customers with the best selection of food at the most affordable prices. Our GoFood Ads business team plays a crucial role in helping merchants grow their businesses through ads solutions, and in scaling Gojek’s revenue. On a day-to-day basis, we try to understand various merchants’ needs - from large fast food restaurants to small UMKM merchants,&nbsp; and then design personalized and impactful ad solutions for them.&nbsp;</span></div><div><br></div><div><span style=\"font-size: 10pt\">Our main responsibility is to constantly ensure that GoFood maintains its position as a market leader in a sustainable manner. How does one achieve this, you may ask? By becoming strategic, data-driven, yet pragmatic in everything that we do. Along with a common drive to use technology to better our community, given the nature of our department, our team bonds over our shared love for good food and the best spots to eat in town. We’re the literal embodiment of Foodies (who can blame us when we work for one of the largest food delivery platforms in Asia!). We’ve also been having fun with board games! (Avalon and Mafia are team favorites).</span></div><div><br></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Ads","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1709264557847,"descriptionPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","description":"<div><span style=\"font-size: 10pt\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","id":"eaab5bee-084d-4cdc-bd08-63230251009c","lists":[{"text":"What you will do","content":"<li>Develop and maintain supply related dashboards to monitor key metrics and compare achievements against targeted <a href=\"http://goals.Analyze\" class=\"postings-link\">goals.</a></li><li><a href=\"http://goals.Analyze\" class=\"postings-link\">Analyze</a> various data points, detect anomalies and spot trends to drive business and strategic decision-making on supply <a href=\"http://initiatives.Collaborate\" class=\"postings-link\">initiatives.</a></li><li><a href=\"http://initiatives.Collaborate\" class=\"postings-link\">Collaborate</a> with the BI, Data Science, Marketing, and Product Management teams to ensure alignment on data analysis, methodologies, insights, and recommendations and proactively escalate issues to relevant <a href=\"http://stakeholders.Analysis\" class=\"postings-link\">stakeholders.</a></li><li><a href=\"http://stakeholders.Analysis\" class=\"postings-link\">Analysis</a> on the competitive intelligence insights and <a href=\"http://findings.Be\" class=\"postings-link\">findings.</a></li><li><a href=\"http://findings.Be\" class=\"postings-link\">Be</a> the go-to person on anything related to the supply health metrics and analysis.</li><div><br></div>"},{"text":"What you will need","content":"<li>A BS/MS in Business, Engineering, Computer Science, Mathematics, Economics or equivalent experience</li><li>3+ years of experience within one or more of the following fields: Business Analytics, Strategy and Planning, Growth or relevant functions</li><li>Comfortable analyzing large amounts of raw data with an obsession to detail and accuracy of data</li><li>Able to uncover the story and relationship behind the numbers and communicate the insights to a wider audience</li><li>A proactive team-player who can work under pressure and tight deadlines</li><li>Proficiency in multiple analytic, database, and visualization tools (e.g., Tableau, Looker Studio, etc.) along with strong knowledge of SQL</li><li>A scientific and hypothesis-driven thinking process with the ability to work in increments and exponents</li><li>Strong project management skills to manage complex projects and to prioritize and effectively collaborate with multiple internal and external stakeholders </li><div><br></div>"}],"text":"Supply Strategy Data Analyst [Ads]","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><span style=\"font-size: 10pt;\">As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.</span></div>","descriptionBodyPlain":"As a Supply Strategy Data Analyst, you will be an integral player in the overall Ads supply strategy team. You'll take full ownership of answering the why and the what through data-driven problem solving. If you are passionate about transforming data into actionable intelligence and thrive in a collaborative environment, this role offers an exciting opportunity to shape the supply growth for Gojek Ads. You'll have a direct impact on ensuring the business maintains its market leadership in Indonesia.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c","applyUrl":"https://jobs.lever.co/GoToGroup/eaab5bee-084d-4cdc-bd08-63230251009c/apply"},{"additionalPlain":"About the team \n\nWe are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.\n\n","additional":"<div><b>About the team</b>&nbsp;</div><div><br></div><div>We are a small but mighty team within GoTo, covering sustainability for all of the operating companies within the group and markets where GoTo operates. Since our inception, we have focused on creating and advancing credible, meaningful impacts in addressing the environmental and social issues most relevant for our stakeholders. We are here for all of the stakeholders in our ecosystem; our driver partners, merchants and sellers, consumers, and many more. Joining this team means you will get hands-on experience in the practical implementation of ESG best practices, and learn how to develop and execute landmark sustainability initiatives across our company and ecosystem.</div><div><br></div>","categories":{"commitment":"Permanent","department":"HoldCo - ESG","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721114762245,"descriptionPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","description":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","id":"1a303596-73f9-4d05-85f9-73cd361f03ef","lists":[{"text":"What you will do","content":"<li>Leading GoTo Group’s sustainability commitments and related workstreams, focusing on the company's environmental and socio-economic impact and financial inclusion of the ecosystem.</li><li>Overseeing Zero Barriers as a socio-economic pillar, focusing on the development of in-house financial products and services aimed at improving the economic well-being and sustainable livelihoods of GoTo’s drivers and merchant partners.</li><li>Implementing impact measurement frameworks to transparently communicate social and economic benefits resulting from company initiatives, reinforcing accountability.&nbsp;</li><li>Driving the implementation of comprehensive Diversity, Equity, and Inclusion (DEI) policies within GoTo, to foster a culture of equality and respect organization-wide.&nbsp;</li><li>Ensuring proactive compliance with relevant environmental, social, and governance (ESG) regulations, surpassing standards to uphold ethical business practices.</li>"},{"text":"What you will need","content":"<li>Extensive experience in ESG strategy, preferably within the tech industry.&nbsp;Strong understanding of global and local sustainability regulations and standards. (GRI, POJK, MSCI, S&amp;P, etc.)</li><li>Proven track record in leading sustainability initiatives and integrating them into business operations.</li><li>Excellent stakeholder management and communication skills.&nbsp;</li><li>Ability to analyze complex data and translate it into actionable strategies.&nbsp;Innovative thinking and problem-solving abilities.&nbsp;</li><li>Leadership skills with the ability to drive cultural change and motivate teams.&nbsp;</li><li>Proficiency in project management and sustainability reporting tools.</li>"}],"text":"Sustainability Senior Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role </b></div><div><br></div><div>The role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.</div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role \n\nThe role entails developing and embedding sustainability best practices across all business operations. The primary challenges include navigating regulatory landscapes, aligning diverse stakeholders, and driving cultural change within a rapidly evolving industry. This role’s scope encompasses strategizing for carbon neutrality, waste reduction, and social impact initiatives. In the first six months, the individual will significantly influence GoTo's sustainability roadmap, fostering eco-friendly innovations and ensuring compliance with global sustainability standards, thereby setting a strong foundation for long-term environmental, social, and governance responsibility.\n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef","applyUrl":"https://jobs.lever.co/GoToGroup/1a303596-73f9-4d05-85f9-73cd361f03ef/apply"},{"additionalPlain":"About the Team\n\nTechnical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.  TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About the Team</b></div><div><br></div><div>Technical Program Management (TPM) is a new role within Gojek that will mature our engineering platform, play a critical role in establishing shared systems, fostering engineering excellence and a healthy engineering community across all of our products.&nbsp; TPMs are experienced technologists responsible for creating clarity, ensuring we’re working on the right things, driving execution and managing risks on critical projects that involve quite a bit of cross-group collaboration.</div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Engineering Platform","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720377852482,"descriptionPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","description":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","id":"ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","lists":[{"text":"What You Will Do","content":"<li>Manage the execution of multiple high-complexity, technically-oriented projects in parallel.</li><li>Build healthy project teams that are productive, efficient, and fun to be part of.</li><li>Develop roadmaps that capture both short-term milestones and the long-term direction for each project.</li><li>Proactively address issues and communicate status for your team and your partners to bring projects in on time and within budget.</li><li>Identify and predict risks to projects across multiple teams and develop mitigation and contingency plans to address them.</li><li>Incorporate metrics into all stages and communications of projects to remove subjectivity and ensure data-driven decision-making.</li><li>Identify opportunities to help Gojek build a technology platform that is both a cutting-edge competitive advantage and incredibly cost-efficient.</li>"},{"text":"What You Will Need","content":"<li>A track record of success working closely with customers (internal or external) to thoroughly understand their problem space, clearly articulate their requirements, and facilitate the work to build their solutions.</li><li>An insatiable need for clarity - you are not phased by ambiguity and will push hard to ensure goals, milestones, roles, responsibilities, dependencies, risks, etc. are all crystal clear to everyone involved.</li><li>Extraordinary communication skills - you have the ability to write and present ideas clearly, concisely, and in an engaging manner. You are an active listener and have deep empathy for the people around you.</li><li>Exceptional collaboration skills - you understand the importance of relationships, you know who is fully on board, who is not, and why. You have the drive and the ability to build teams and coalitions. You ensure everyone feels they have been heard, drive alignment, and inspire commitment to the goal.</li><li>A strong drive for results - you understand the difference between activity and impact. You prioritize and measure success based on the scale of the contribution you can make. You’re expected to be a big-picture thinker and strategic partner but you’re also willing to get your hands dirty and do whatever it takes to help your team deliver high-quality work against tight deadlines.</li><li>Good understanding of Technology and ability to coordinate with Engineering and Product Management teams to build roadmaps and help problem solve issues by building and implementing technical solutions.</li>"}],"text":"Technical Program Manager - Engineering Platform","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>The Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on.&nbsp;</div><div>&nbsp;</div><div>As a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.&nbsp; &nbsp;</div><div><br></div><div>You will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders.&nbsp;</div>","descriptionBodyPlain":"About the Role\n\nThe Technical Program Management (TPM) team has been tasked with making our engineering teams, especially the Engineering Platform team, more effective by identifying and executing opportunities to organize shared engineering systems and initiatives, to bring about useful standards, to foster the creation of learning materials, training opportunities and so on. \n \nAs a TPM for Engineering Platform, you’ll be responsible for organizing and driving our efforts to develop and drive the adoption of solutions built in this space. This is a leadership role that requires you to have a solid foundation of both technical and collaborative skills that can be used to effectively influence a large, diverse, and talented engineering organization.   \n\nYou will collaborate closely with Engineering Platform, SRE, Infosec, and PDG teams to manage infrastructure budget/cost including but not limited to finding opportunities for optimization, assisting in the execution of programs, and performing operational tasks such as financial reporting, planning, and facilitation of requirement gatherings and meetings with several stakeholders. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3","applyUrl":"https://jobs.lever.co/GoToGroup/ad8878c9-2842-4f0b-b0f7-d9ed4e78f6a3/apply"},{"additionalPlain":"About The Team\n\nOur Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.\n\nWe pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.\n","additional":"<div><b>About The Team</b></div><div><br></div><div>Our Public Policy and Government Relations Team is a dynamic group of over 20 professionals dedicated to addressing the regulatory landscape across diverse sectors such as Transportation, Food, and Groceries. We excel in forging strategic partnerships with government entities and navigating regulatory hurdles. How do we succeed? Through crafting top-tier engagement strategies and developing policy solutions that are supported by comprehensive analysis, research, and data.</div><div><br></div><div>We pride ourselves on being a close-knit team—truly a second family to each other. When you join us, you can count on our full support to help you integrate and perform with confidence from day one. We believe wholeheartedly in the power of teamwork, fostering a collaborative environment where both professional insights and personal interests are shared openly during our daily calls.</div>","categories":{"commitment":"Permanent","department":"ODS - Public Policy & Government Relations","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1720689871979,"descriptionPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","description":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","id":"bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","lists":[{"text":"What You Will Do","content":"<li>Relationship Building: Support Head in establishing and strengthening relationships with government officials, nonprofit groups, and other key institutions across Indonesia and Southeast Asia</li><li>Policy Development: Collaborate with multiple stakeholders to develop a strategic and actionable public policy plan that aligns with organizational goals</li><li>Internal Coordination: Work closely with internal teams within GoTo’s group of companies to ensure cohesive strategy execution across various sectors</li><li>Project Leadership: Support multiple projects in partnership with government institutions, focusing on Transport and Mobility technology.</li><li>Networking and Alliance Building: Cultivate and leverage relationships with a broad network including government, non-government stakeholders, civil society, thought leaders, industry associations, and think tanks to forge strategic alliances</li><li>Project Management: Support public policy projects that involve cross-functional teams and external stakeholders, ensuring successful outcomes and alignment with broader business objectives</li>"},{"text":"What You Will Need","content":"<li>Bachelor’s degree in Law, Politics, International Relations, or Economics from a reputable university; Master’s degree preferred</li><li>At least five years in a managerial role within public policy and government relations, or in sectors such as law firms, think tanks, civil society organizations, or government</li><li>Established network among government stakeholder with a proven impact on policy decisions</li><li>Strong analytical, problem-solving, communication skills, and independent project management capabilities.</li>"}],"text":"Transport and Mobility PPGR Manager","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About The Role</b></div><div><br></div><div>The individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. </div>","descriptionBodyPlain":"About The Role\n\nThe individual will lead regulatory matters impacting the transport and mobility sector, ensuring the business and its expansion are protected from government oversight and regulatory challenges. \n","hostedUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b","applyUrl":"https://jobs.lever.co/GoToGroup/bf9ad9be-9cca-41e0-9c6d-a6b66e91726b/apply"},{"additionalPlain":"About GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"FinTech - Consumer Lending","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1705901801143,"descriptionPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","description":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","id":"17408b81-f5a0-4f15-afae-cc04ed7e43b6","lists":[{"text":"What You Will Do","content":"<li>Prepare Risk reporting and position reporting</li><li>Conduct assessments to define and analyze possible risks</li><li>Evaluate the gravity of each risk by considering its consequences</li><li>Design processes to eliminate or mitigate potential risks</li><li>Evaluate existing policies and procedures to find weaknesses</li><li>Prepare reports and present recommendations</li><li>Ensure risk exposures of the company is within stipulated limits</li><li>Work closely with other business stakeholders</li>"},{"text":"What You Will Need","content":"<li>Have experience in lending business at least 2 years&nbsp;</li><li>Have experience in conducted detailed risk assessments&nbsp;</li><li>Have experience in analyzing documents, statistics, reports and trends of both internal and external data</li><li>Have good communication and adaptive skills, be responsible and discipline in data providing</li><li>Have knowledge and experience of working with SQL will be an advantage</li><li>Independent, organized, highly analytical and proactive</li>"}],"text":"Underwriting and Credit Analyst","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div>As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.</div>","descriptionBodyPlain":"As an Underwriting and Credit Risk Analyst, you will be involved in preparing and presenting comprehensive risk and position reports, conducting assessments to analyze potential risks, and designing processes to mitigate and eliminate identified risks. You will collaborate with business stakeholders to evaluate existing policies, identify weaknesses, and make recommendations to ensure the company's risk exposure remains within established limits.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6","applyUrl":"https://jobs.lever.co/GoToGroup/17408b81-f5a0-4f15-afae-cc04ed7e43b6/apply"},{"additionalPlain":"About The Team\nMerchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.\n\n\nAbout GoTo Group\nGoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.\n\nAbout Gojek \nGojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.\n\nAbout GoTo Financial\nGoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.\n\nGoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.\n","additional":"<div><b style=\"font-size: 18px\">About The Team</b></div><div><span style=\"font-size: 16px\">Merchant Engagement is a team that is very passionate to build and improve the digitization of MSME business, especially unmanaged merchants of Gojek nationwide. We like to play the game with multiple stakeholders both internal and external. We also love playing with data and are working closely with the region team to brainstorm and A/B test together as well as learn from it.</span></div><div><br></div><div><b>About GoTo Group</b></div><div>GoTo Group is the largest digital ecosystem in Indonesia with its mission to “Empower Progress’ by offering technological infrastructure and solutions for everyone to access and thrive in the digital economy. The GoTo ecosystem consists of on-demand transportation services, food and grocery delivery, logistics and fulfillment, as well as financial and payment services through the Gojek and GoTo Financial platforms.It is the first platform in Southeast Asia that hosts these crucial cases in a single ecosystem, capturing the majority of Indonesia’s vast consumer household.</div><div><br></div><div><b>About Gojek&nbsp;</b></div><div>Gojek is Southeast Asia’s leading on-demand platform and pioneer of the multi-service ecosystem with over 2.5 million driver partners across the regions offering a wide range of services such as transportation, food delivery, logistics and more. With its mission to create impact at scale, Gojek is committed to resolving consumer problems and raising standards of living by connecting consumers to the best providers of goods and services in the market.</div><div><br></div><div><b>About GoTo Financial</b></div><div>GoTo Financial accelerates financial inclusion through its leading financial services and merchants solutions. Its consumer services include GoPay and GoPayLater and serve businesses of all sizes through Midtrans, Moka, GoBiz Plus, GoBiz, and Selly. With its trusted and inclusive ecosystem of products, GoTo Financial is open to new growth opportunities and aims to empower everyone to Make It Happen, Make It Together, Make It Last.</div><div><br></div><div><i>GoTo and its business units, including Gojek and GoToFinancial (\"GoTo\") only post job opportunities on our official channels on&nbsp;our respective company websites and on LinkedIn. GoTo is not liable for any job postings or job offers that did not originate from us. You should conduct your own due diligence to prevent being victims of any fake job scams, if they did not originate from GoTo's official recruitment channels.</i></div>","categories":{"commitment":"Permanent","department":"ODS - Sales","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721636128423,"descriptionPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","description":"<div><b style=\"font-size: 18px\">About The Role</b></div><div><span style=\"font-size: 16px\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","id":"a007af4b-690d-4487-874d-f04ce3f62ce0","lists":[{"text":"What You Will Do","content":"<li>Maintain relationship with BPO vendor and regularly evaluate their productivity&nbsp;</li><li>Become a COE of merchant engagement framework for region team</li><li>Assisting SM Merchant Engagement in managing milestones, timeline, as well the stakeholders engagement related to the managed projects.</li><li>Develop and updating Key Insights and Analysis related to Unmanaged merchants performances</li>"},{"text":"What This Role Needs","content":"<li>At least 2 years experience in field sales or telemarketing, especially with a proven track record of managing local / regional business in reputable companies</li><li>Experienced in managing large business partner such as distributor or outsourcing vendor</li><li>Have experience in basic to intermediate data analytics skills</li><li>Having ability to turn insight into actionable plan</li><li>Strong business acumen with proven track record in stakeholder management</li>"}],"text":"Unmanaged Merchant Engagement Senior Associate - #10326","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b style=\"font-size: 18px;\">About The Role</b></div><div><span style=\"font-size: 16px;\">As a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal &amp; external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.</span></div>","descriptionBodyPlain":"About The Role\nAs a Merchant engagement associate, you will be supporting the SM, Merchant Engagement to build and maintain a strong relationship with every stakeholder (internal & external) to grow all of the unmanaged merchants in Gojek ecosystem. You will work closely with BPO vendor to manage all the telesales and account development team, conduct a regular business review with them and help them to reach the targeted objective.\n","hostedUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0","applyUrl":"https://jobs.lever.co/GoToGroup/a007af4b-690d-4487-874d-f04ce3f62ce0/apply"},{"additionalPlain":"About the team \n\nAt the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.\nJoin us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!\n\n","additional":"<div><b>About the team </b></div><div><br></div><div>At the Groceries product group, we're revolutionizing how people get their daily staples with our lightning-fast, on-demand delivery service. GoMart, our flagship B2C online grocery platform, has skyrocketed to the top, leading the quick commerce market and delivering convenience items to delighted consumers in over 100 cities across Indonesia. Our mission is to empower merchant partners nationwide, helping them thrive while ensuring our customers receive their daily essentials swiftly and reliably.</div><div>Join us on this thrilling journey to shape the future of the independent movement for everyone and everything. We're a diverse team that values curiosity, a passion for technology, and a collaborative spirit. If you're driven by innovation and excited about solving real-world problems with cutting-edge tech, we want you on our team. Let's create the future together!</div><div><br></div>","categories":{"commitment":"Permanent","department":"ODS - Groceries","location":"Jakarta","team":"-","allLocations":["Jakarta"]},"createdAt":1721119556899,"descriptionPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","description":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","id":"147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","lists":[{"text":"What you will do","content":"<li>Own the GoMart Growth Strategy and Promotion budgetTake charge of monthly budgeting and weekly execution with an emphasis on growth while maintaining profitability</li><li>Lead initiatives, strategies, and implementation, with a primary focus on the customer lifecycle funnel targeting the acquisition of new and churned users while growing retention of existing customers through a compelling offer.</li><li>Experiment with a combination of multiple initiatives (e.g. vouchers/promotion, product or pricing changes) to validate initiatives through statistical analysis</li><li>Use data across customer, driver, and merchant activity from multiple products to hypothesize potential solutions and test them in practice&nbsp;</li><li>Collaborate with Merchandising, Marketing, Product, and Operations teams in the development and implementation of initiatives and strategies</li><li>Prepare routine reports and present findings to leadership as the basis of rationale and recommendations for strategic decision-making</li>"},{"text":"What you will need","content":"<li>At least 5 years of experience in strategy or growth role at a tech company, e-commerce, or management consulting background</li><li>Strong proficiency in Microsoft Excel; Understanding of SQL and other statistical tools is a must.</li><li>Strong business acumen, an end-to-end problem-solving mindset with the ability to work in increments and exponents and balance attention to detail with swift execution</li><li>Leadership skills to manage direct and indirect stakeholders with various backgrounds</li><li>Strong communication and project management skills with experience managing projects with multiple stakeholders</li><li>The ability to move and execute quickly in a time-efficient manner to allow for continual iteration is a core competency of our team</li>"}],"text":"User Growth Lead","country":"ID","workplaceType":"onsite","opening":"","openingPlain":"","descriptionBody":"<div><b>About the Role</b></div><div><br></div><div>Imagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. </div><div>Our User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.</div><div>Fuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. </div><div><br></div><div><br></div>","descriptionBodyPlain":"About the Role\n\nImagine crafting growth strategies and roadmaps that skyrocket our customer base and profitability by doing experimentation and research. That's the reality for our User Growth Lead! Be the mastermind behind game-changing rewards, promotions, loyalty programs, and customer journeys. \nOur User Growth Lead role offers the perfect blend of strategic thinking and hands-on execution.\nFuel your curiosity and challenge yourself! As a User Growth Lead, you'll constantly learn and develop strategies that push our boundaries. This role gives you the autonomy to design and implement high-impact growth initiatives. Be part of an aggressively growing product that is changing an industry. \n\n\n","hostedUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663","applyUrl":"https://jobs.lever.co/GoToGroup/147bc8e3-4bcf-4a4a-a64e-97c0e0ea3663/apply"}]
+  recorded_at: Tue, 30 Jul 2024 16:28:30 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.gotocompany.com/"]}],"limit":1}'
@@ -150,9 +150,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:06:47 GMT
+      - Tue, 30 Jul 2024 16:28:30 GMT
       Etag:
-      - W/"1722244007512"
+      - W/"1722356910713"
       Server:
       - openresty
       X-Cb-Engine:
@@ -168,7 +168,7 @@ http_interactions:
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '16'
+      - '14'
       Content-Length:
       - '525'
       Connection:
@@ -179,8 +179,8 @@ http_interactions:
         Group","identifier":{"permalink":"goto-group","image_id":"pioqotgm6efdzbjvkirg","uuid":"0f2e5ecc-d44c-49c0-9e36-7a117fb1eedc","entity_def_id":"organization","value":"GoTo
         Group"},"linkedin":{"value":"https://www.linkedin.com/company/gotogroup"},"short_description":"GoTo
         Group offers a digital ecosystem for on-demand services, e-commerce, fintech,
-        and logistics.","rank_org":4994,"website_url":"https://www.gotocompany.com"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:06:47 GMT
+        and logistics.","rank_org":4989,"website_url":"https://www.gotocompany.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:30 GMT
 - request:
     method: get
     uri: https://api.lever.co/v0/postings/GoToGroup/f53cae40-f605-4215-9a82-b48c5db508b5?customQuestions=true
@@ -200,7 +200,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:48 GMT
+      - Tue, 30 Jul 2024 16:28:31 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -221,7 +221,7 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         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
-  recorded_at: Mon, 29 Jul 2024 09:06:48 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:31 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Bengaluru?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -241,7 +241,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:48 GMT
+      - Tue, 30 Jul 2024 16:28:31 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -259,18 +259,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 803223b45be09c11576d5c571db3cfd8
+      - d259937a6eb29eea1b00b26af53497fe
       X-Msedge-Ref:
-      - 'Ref A: 4554EC248E2547BE98086A49487FB9EA Ref B: DB3EDGE2809 Ref C: 2024-07-29T09:06:48Z|Ref
-        SnR: 66a75ba8004c4fbfa6b14de99e0a6547'
+      - 'Ref A: ACD62F62EE1C417BB5FA31E402200E4F Ref B: DB3EDGE2915 Ref C: 2024-07-30T16:28:31Z|Ref
+        SnR: 66a914af531c4a47b5c34a35d61983da'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-8z5f6, mapsplatform-forwardgeocoder-service-69c675d4f5-9fk55
+      - mapsplatform-frontend-5989d449fd-ldtnd, mapsplatform-forwardgeocoder-service-69c675d4f5-lstqp
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '70'
+      - '61'
       X-Azure-Ref:
-      - 20240729T090648Z-17cc7bff758s7gf6pf31by528n00000008s0000000009xre
+      - 20240730T162831Z-154b59dbc6dwlvkrbdum70qw7s00000007kg0000000102p8
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -278,8 +278,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:48 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:31 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Bengaluru?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -299,7 +299,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:48 GMT
+      - Tue, 30 Jul 2024 16:28:31 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -317,18 +317,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 1e123413b66765599bc73ef09b6e8391
+      - 2a399e6e1b5e1696de2ae8cd1a711772
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75ba8ae4f4caf88e9f125011f1cd9|Ref A: 0D28CF01564D4C46991765C707F528C1
-        Ref B: DB3EDGE2615 Ref C: 2024-07-29T09:06:48Z'
+      - 'Ref A: F18916C0F1804A62B48A8E2F27A31A1F Ref B: DB3EDGE1912 Ref C: 2024-07-30T16:28:31Z|Ref
+        SnR: 66a914afa7774753813c46edfa8c6a96'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-dd2gk, mapsplatform-forwardgeocoder-service-69c675d4f5-ltvqp
+      - mapsplatform-frontend-5989d449fd-dd2gk, mapsplatform-forwardgeocoder-service-69c675d4f5-6d962
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '70'
+      - '66'
       X-Azure-Ref:
-      - 20240729T090648Z-154b59dbc6dsvkxvhc2pneb8g000000004wg000000011qet
+      - 20240730T162831Z-154b59dbc6dbfz5w4e0zaun7z40000000a20000000007pd0
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -336,6 +336,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6NCwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzEyLjY1OTY1ODQzMjAwNjgzNiw3Ny4zMjUzNjMxNTkxNzk2OSwxMy4yMzQ5ODQzOTc4ODgxODQsNzcuODMzNjQ4NjgxNjQwNjJdLCJuYW1lIjoiQmVuZ2FsdXJ1LCBJbmRpYSIsInBvaW50Ijp7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbMTIuOTc2NzQ2NTYsNzcuNTc1Mjc5MjRdfSwiYWRkcmVzcyI6eyJhZG1pbkRpc3RyaWN0IjoiS0EiLCJjb3VudHJ5UmVnaW9uIjoiSW5kaWEiLCJmb3JtYXR0ZWRBZGRyZXNzIjoiQmVuZ2FsdXJ1LCBJbmRpYSIsImxvY2FsaXR5IjoiQmVuZ2FsdXJ1In0sImNvbmZpZGVuY2UiOiJIaWdoIiwiZW50aXR5VHlwZSI6IlBvcHVsYXRlZFBsYWNlIiwiZ2VvY29kZVBvaW50cyI6W3sidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlsxMi45NzY3NDY1Niw3Ny41NzUyNzkyNF0sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfSx7Il9fdHlwZSI6IkxvY2F0aW9uOmh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vc2VhcmNoL2xvY2FsL3dzL3Jlc3QvdjEiLCJiYm94IjpbMTIuMzIwMDc3NTU5NTI4OTMzLDc2LjYzOTk5OTYwODY0Nzk0LDEyLjMyNzgwMjk5NDY3MDI4Niw3Ni42NTA1NDI5OTM4OTExMl0sIm5hbWUiOiJCZW5nYWx1cnUsIEluZGlhIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlsxMi4zMjM5NDAyOCw3Ni42NDUyNzEzXX0sImFkZHJlc3MiOnsiYWRtaW5EaXN0cmljdCI6IktBIiwiY291bnRyeVJlZ2lvbiI6IkluZGlhIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkJlbmdhbHVydSwgSW5kaWEiLCJsb2NhbGl0eSI6IkJlbmdhbHVydSJ9LCJjb25maWRlbmNlIjoiTWVkaXVtIiwiZW50aXR5VHlwZSI6Ik5laWdoYm9yaG9vZCIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbMTIuMzIzOTQwMjgsNzYuNjQ1MjcxM10sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfSx7Il9fdHlwZSI6IkxvY2F0aW9uOmh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vc2VhcmNoL2xvY2FsL3dzL3Jlc3QvdjEiLCJiYm94IjpbMTIuNjU3NDM1NDE3MTc1MjkzLDc3LjMyNTUzMTAwNTg1OTM4LDEzLjIzMzA1MzIwNzM5NzQ2MSw3Ny44NDc1OTUyMTQ4NDM3NV0sIm5hbWUiOiJCYW5nYWxvcmUgVXJiYW4iLCJwb2ludCI6eyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzEyLjk3Njc0NjU2LDc3LjU3NTI3OTI0XX0sImFkZHJlc3MiOnsiYWRtaW5EaXN0cmljdCI6IktBIiwiYWRtaW5EaXN0cmljdDIiOiJCYW5nYWxvcmUgVXJiYW4iLCJjb3VudHJ5UmVnaW9uIjoiSW5kaWEiLCJmb3JtYXR0ZWRBZGRyZXNzIjoiQmFuZ2Fsb3JlIFVyYmFuIn0sImNvbmZpZGVuY2UiOiJMb3ciLCJlbnRpdHlUeXBlIjoiQWRtaW5EaXZpc2lvbjIiLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzEyLjk3Njc0NjU2LDc3LjU3NTI3OTI0XSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19LHsiX190eXBlIjoiTG9jYXRpb246aHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS9zZWFyY2gvbG9jYWwvd3MvcmVzdC92MSIsImJib3giOlsxMi45NDEyNDM1MDcwODMxMjYsNzcuNTIwNjUzNjA1OTg5NTEsMTIuOTk5MTg0MjczMDY4MjQxLDc3LjU5OTkyMTM0NTE4MjM3XSwibmFtZSI6IkJhbmdhbG9yZSBVcmJhbiBkaXN0cmljdCwgSW5kaWEiLCJwb2ludCI6eyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzEyLjk3MDIxMzg5LDc3LjU2MDI4NzQ4XX0sImFkZHJlc3MiOnsiY291bnRyeVJlZ2lvbiI6IkluZGlhIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkJhbmdhbG9yZSBVcmJhbiBkaXN0cmljdCwgSW5kaWEiLCJsb2NhbGl0eSI6IkJhbmdhbG9yZSBVcmJhbiBkaXN0cmljdCJ9LCJjb25maWRlbmNlIjoiTG93IiwiZW50aXR5VHlwZSI6IlBvcHVsYXRlZFBsYWNlIiwiZ2VvY29kZVBvaW50cyI6W3sidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlsxMi45NzAyMTM4OSw3Ny41NjAyODc0OF0sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfV19XSwic3RhdHVzQ29kZSI6MjAwLCJzdGF0dXNEZXNjcmlwdGlvbiI6Ik9LIiwidHJhY2VJZCI6IjFlMTIzNDEzYjY2NzY1NTk5YmM3M2VmMDliNmU4MzkxIn0=
-  recorded_at: Mon, 29 Jul 2024 09:06:48 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:31 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_manatal.yml b/spec/fixtures/cassettes/create_job_manatal.yml
index 02357a5a..4a0b196a 100644
--- a/spec/fixtures/cassettes/create_job_manatal.yml
+++ b/spec/fixtures/cassettes/create_job_manatal.yml
@@ -19,11 +19,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:49 GMT
+      - Tue, 30 Jul 2024 16:28:32 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '21455'
+      - '19729'
       Connection:
       - keep-alive
       Server:
@@ -44,8 +44,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1930649,"hash":"QVXR6YY8","position_name":"Accounts Analyst - Receivable/Payable (fluent in Swedish)","description":"<p><strong>Position: Accounts Analyst - Receivable/Payable&nbsp;(fluent in Swedish)</strong></p>\n<p><strong>Location: Aveiro, Portugal</strong></p>\n<p><br></p>\n<p>Our client is a global innovation and solutions partner, manufacturing low-emission and alternative fuel power needs. Their mission is to provide next-generation powertrain solutions as markets around the world transition to a more sustainable future.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsibilities:</strong></p>\n<p>This person will report to the Head of Accounting and will support the Accounts Receivable and/or Accounts Payable areas of our client. It is estimated that around 3,500 to 4,000 invoices will be processed each month.</p>\n<ul><li>Issuing and posting invoices for sales and general expenses</li><li>Accounting for receipts, invoices for parts purchases, and invoices for fixed assets</li><li>Bank reconciliation</li><li>Checking prices and receipts on the customer platform</li><li>Managing accounts receivable (customers and invoices) and FAR accounts (goods received/invoices not received)</li><li>Monitoring due dates and collections</li><li>Default management and negotiation with clients</li><li>Managing supplier complaints</li><li>Collaboration in reviewing credit and payment proposals</li><li>Invoice and invoice corrections</li><li>Control of receipts, generation of financial reports and IBS control</li><li>Customer service and resolving issues related to invoices and payments</li></ul>\n<p><strong><br></strong></p>\n<p><strong>﻿Requirements:</strong></p>\n<ul><li>Degree in Business Administration and Management, Economics or Business Sciences, or similar field;</li><li>Professional experience: 2 to 3 years in the field.</li><li>Languages: fluent English and Swedish required (regular communication with foreign countries); Spanish and/or Portuguese valuable.</li><li>Experience in SAP and Excel.</li><li>Be available to work in Portugal.﻿</li></ul>","country":"Sweden","state":"","city":"Stockholm","address":"","zipcode":"","location_display":"Stockholm, Sweden","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938459,"hash":"L96575V4","position_name":"AI & Computer Vision Developer","description":"<p><strong>Posição: AI &amp; Computer Vision Developer</strong><br></p>\n<p><strong></strong><strong>Localização: Guimarães (híbrido)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma empresa especialista em visão artificial, integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a <strong>automatização de processos</strong>.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p></p>\n<ul>\n <li>Aplicar técnicas em visão computacional e inteligência      artificial para construção de algoritmos e sistemas inteligentes para      aplicação nos projetos e produtos do cliente.</li>\n <li>Desenvolver software para aplicações em grande escala.</li>\n <li>Disposição para trabalhar num ambiente dinâmico e flexível.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul>\n <li>BS,      MS ou Ph.D. licenciatura em Ciência da Computação, Engenharia ou área      relacionada.</li>\n <li>+2      anos de experiência numa das seguintes áreas: visão computacional,      inteligência artificial, sistemas informáticos.</li>\n <li>Experiência      em programação em C / C++ e QT.</li>\n <li>Experiência com Halcon, OpenCV ou outra ferramenta especializada em      computer vision.</li><li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1698635,"hash":"L9V5Y99Y","position_name":"Analista de Contas a Pagar e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Pagar e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p><br>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.<br>﻿<br>﻿<strong><br>﻿Responsabilidades:</strong></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Pagar do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p>\n<ul><li>Lançamento de faturas de despesas gerais</li><li>Contabilização de faturas de compra de peças e posterior gestão de estoque</li><li>Verificação de preços na plataforma do cliente</li><li>Contabilização de faturas de ativos fixos</li><li>Lançamento de faturas FI (Débito Direto)</li><li>Gestão de contas FAR (Bens recebidos/Faturas não recebidas)</li><li>Gestão de reclamações de fornecedores</li><li>Colaboração na revisão de propostas de pagamento</li><li>Correções de fatura</li><li>Controlo da SII</li></ul>\n<p><br>﻿<strong><br>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional:&nbsp;2 a 3 anos na área.&nbsp;</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933733,"hash":"L763WY85","position_name":"Analista de Custos(ferramental)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos&nbsp;qualificado e experiente para atuar na área de ferramental de injeção plástica.</p>\n<h3>Requisitos</h3>\n<ul><li>Conhecimento avançado em ferramental de injeção plástica, incluindo os custos envolvidos na produção, manutenção e reparo das ferramentas.</li><li>Habilidades mestras em tecnologia periférica de ferramental de injeção, tais como sistemas de câmera quente, válvulas sequenciais, acionamentos hidráulicos ou pneumáticos, entre outros.</li><li>Leitura e escrita técnica em língua inglesa, para comunicação com fornecedores e clientes internacionais.</li><li>Experiência em atividades relacionadas ao ferramental de injeção plástica, tais como:</li><li>Try outs: realização de testes de moldagem com as ferramentas, verificando a qualidade e a conformidade dos produtos.</li><li>Liberação de ferramental: emissão de relatórios e documentos que atestam a aptidão das ferramentas para a produção.</li><li>Inspeção / desenvolvimento de ferramentas Soft e Hard: avaliação e aprimoramento das características técnicas e funcionais das ferramentas, tanto em estágio inicial (Soft) quanto em estágio final (Hard).</li><li>Aprovação de texturização: análise e validação da textura aplicada nas superfícies das ferramentas, de acordo com as especificações do cliente.</li><li>Validação dimensional: medição e verificação das dimensões das ferramentas e dos produtos, utilizando instrumentos de precisão e seguindo os padrões de tolerância.</li><li>Modificação de produto: execução de alterações nas ferramentas, conforme solicitação do cliente ou necessidade de melhoria do produto.</li><li>Auditorias de ferramental em injetores parceiros: inspeção e controle da qualidade das ferramentas utilizadas por empresas terceirizadas que prestam serviços de injeção plástica.</li><li>Acompanhamento de FMEA: participação na análise de modos de falha e seus efeitos, identificando e prevenindo possíveis problemas nas ferramentas e nos produtos.</li><li>Acompanhamento de testes de Moldflow: supervisão e interpretação dos resultados dos testes de simulação computacional do processo de injeção plástica, otimizando o desempenho das ferramentas.</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933713,"hash":"QVXRYW7R","position_name":"Analista de Custos(plásticos)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos com experiência e conhecimento avançado em materiais de injeção, aplicações, propriedades, testes, validação, desenvolvimento de fornecedores, modificações de produto, auditorias e propostas de VAVE.</p>\n<h4><strong>Requisitos</strong></h4>\n<ul><li>Formação superior em Engenharia de custos, Química ou áreas afins.</li><li>Conhecimento avançado em polímeros de engenharia, incluindo os custos envolvidos na sua aplicação.</li><li>Conhecimento avançado em aplicações de polímeros, incluindo os custos envolvidos na sua seleção, especificação e substituição.</li><li>Habilidades de mestre em propriedades de materiais de injeção, incluindo os custos envolvidos na sua otimização, controle e melhoria.</li><li>Habilidades de mestre para resolver problemas de polímeros no processo de injeção, incluindo os custos envolvidos na sua prevenção, detecção e correção.</li><li>Leitura, escrita e fala técnica em inglês, com capacidade de se comunicar com clientes, fornecedores e equipes internacionais.</li><li>Capaz de realizar mudanças de material e análise de fornecedores, incluindo os custos envolvidos na sua avaliação, negociação e homologação.</li><li>Habilidades de mestre em propostas de VAVE (Value Analysis and Value Engineering), incluindo os custos envolvidos na sua elaboração, apresentação e implementação.</li><li>Experiência em:</li><li>Testes de materiais, incluindo ensaios mecânicos, térmicos, ópticos, químicos e ambientais.</li><li>Validação de materiais, incluindo aprovação de cores (padrão), validação dimensional, análise de falhas e emissão de relatórios.</li><li>Desenvolvimento de fornecedores, incluindo pesquisa de mercado, prospecção, qualificação, auditoria e acompanhamento.</li><li>Modificação de produto, incluindo alterações de design, funcionalidade, desempenho e qualidade.</li><li>Auditorias de materiais em parceiros injetores, incluindo verificação de conformidade, rastreabilidade, controle de estoque e gestão de resíduos.</li><li>FMEA (Failure Mode and Effect Analysis) e acompanhamento de Moldflow (simulação de injeção).</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1928936,"hash":"LR4367RX","position_name":"Analista de Dados","description":"<p><strong>Responsabilidades:</strong></p>\n<ul><li>Gerenciar o orçamento designado para projetos de engenharia, garantindo o uso eficiente dos recursos financeiros disponíveis.</li><li>Monitorar e otimizar a distribuição de trabalho entre as diferentes áreas de engenharia, assegurando a eficácia operacional e o cumprimento dos prazos.</li><li>Colaborar com as equipes de projeto para identificar áreas de melhoria e implementar soluções eficazes para aumentar a eficiência e a produtividade.</li><li>Comunicar-se de forma eficaz com diversas interfaces, incluindo equipes de engenharia, líderes de projeto e stakeholders, para alinhar expectativas e garantir o progresso consistente dos projetos.</li></ul>\n<p><strong>﻿Requisitos:</strong></p><p><strong>﻿<br></strong></p>\n<ul><li>Graduação Superior em qualquer área (não necessariamente engenharia), demonstrando sólida formação acadêmica e capacidade analítica.</li><li>Experiência prévia em funções relacionadas a PMO (Project Management Office), planejamento ou controle de projetos.</li><li>Fortes habilidades com planilhas e ferramentas de análise de dados, com capacidade para interpretar e apresentar informações de forma clara e concisa.</li><li>Excelente organização e capacidade de gerenciar múltiplas tarefas simultaneamente, mantendo um alto nível de precisão e atenção aos detalhes.</li><li>Habilidades interpessoais sólidas, capazes de cultivar relacionamentos eficazes com uma variedade de stakeholders.</li><li>Preferencialmente sexo feminino, visando a diversidade e inclusão no ambiente de trabalho.</li><li>Desejável proficiência em inglês avançado</li><li>Data management: Pbi, Automação de relatorios e ppts..</li><li>Experiência com&nbsp;﻿<strong><em>Linguagem M ( PowerQuery ) </em></strong>﻿</li></ul>\n<p></p>\n<p></p>\n<p><br>\n\n</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852358,"hash":"L8657W63","position_name":"Analista de Dados","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><li><strong>Gênero:</strong> Mulher</li><li><strong>Habilidades:</strong><ul><li>Excelente conhecimento em Excel</li><li>Iniciativa</li><li>Conhecimento intermediário ou bom em Power BI</li></ul>\n<p></p>\n<p></p></li><li><strong>Formação:</strong> Técnica</li><li><strong>Idioma:</strong> Inglês</li><li><strong>Regime de Trabalho:</strong> Hibrido / Betim</li><li><br></li><p></p>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:49 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1930649,"hash":"QVXR6YY8","position_name":"Accounts Analyst - Receivable/Payable (fluent in Swedish)","description":"<p><strong>Position: Accounts Analyst - Receivable/Payable&nbsp;(fluent in Swedish)</strong></p>\n<p><strong>Location: Aveiro, Portugal</strong></p>\n<p><br></p>\n<p>Our client is a global innovation and solutions partner, manufacturing low-emission and alternative fuel power needs. Their mission is to provide next-generation powertrain solutions as markets around the world transition to a more sustainable future.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsibilities:</strong></p>\n<p>This person will report to the Head of Accounting and will support the Accounts Receivable and/or Accounts Payable areas of our client. It is estimated that around 3,500 to 4,000 invoices will be processed each month.</p>\n<ul><li>Issuing and posting invoices for sales and general expenses</li><li>Accounting for receipts, invoices for parts purchases, and invoices for fixed assets</li><li>Bank reconciliation</li><li>Checking prices and receipts on the customer platform</li><li>Managing accounts receivable (customers and invoices) and FAR accounts (goods received/invoices not received)</li><li>Monitoring due dates and collections</li><li>Default management and negotiation with clients</li><li>Managing supplier complaints</li><li>Collaboration in reviewing credit and payment proposals</li><li>Invoice and invoice corrections</li><li>Control of receipts, generation of financial reports and IBS control</li><li>Customer service and resolving issues related to invoices and payments</li></ul>\n<p><strong><br></strong></p>\n<p><strong>﻿Requirements:</strong></p>\n<ul><li>Degree in Business Administration and Management, Economics or Business Sciences, or similar field;</li><li>Professional experience: 2 to 3 years in the field.</li><li>Languages: fluent English and Swedish required (regular communication with foreign countries); Spanish and/or Portuguese valuable.</li><li>Experience in SAP and Excel.</li><li>Be available to work in Portugal.﻿</li></ul>","country":"Sweden","state":"","city":"Stockholm","address":"","zipcode":"","location_display":"Stockholm, Sweden","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965495,"hash":"L96W5744","position_name":"AGCO - Almoxarife (reposição)","description":"<p>Almoxarife, com certificação em NR11, para atuar presencialmente em Mogi das Cruzes, horário administrativo&nbsp;</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938459,"hash":"L96575V4","position_name":"AI & Computer Vision Developer","description":"<p><strong>Posição: AI &amp; Computer Vision Developer</strong><br></p>\n<p><strong></strong><strong>Localização: Guimarães (híbrido)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma empresa especialista em visão artificial, integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a <strong>automatização de processos</strong>.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p></p>\n<ul>\n <li>Aplicar técnicas em visão computacional e inteligência      artificial para construção de algoritmos e sistemas inteligentes para      aplicação nos projetos e produtos do cliente.</li>\n <li>Desenvolver software para aplicações em grande escala.</li>\n <li>Disposição para trabalhar num ambiente dinâmico e flexível.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul>\n <li>BS,      MS ou Ph.D. licenciatura em Ciência da Computação, Engenharia ou área      relacionada.</li>\n <li>+2      anos de experiência numa das seguintes áreas: visão computacional,      inteligência artificial, sistemas informáticos.</li>\n <li>Experiência      em programação em C / C++ e QT.</li>\n <li>Experiência com Halcon, OpenCV ou outra ferramenta especializada em      computer vision.</li><li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933733,"hash":"L763WY85","position_name":"Analista de Custos(ferramental)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos&nbsp;qualificado e experiente para atuar na área de ferramental de injeção plástica.</p>\n<h3>Requisitos</h3>\n<ul><li>Conhecimento avançado em ferramental de injeção plástica, incluindo os custos envolvidos na produção, manutenção e reparo das ferramentas.</li><li>Habilidades mestras em tecnologia periférica de ferramental de injeção, tais como sistemas de câmera quente, válvulas sequenciais, acionamentos hidráulicos ou pneumáticos, entre outros.</li><li>Leitura e escrita técnica em língua inglesa, para comunicação com fornecedores e clientes internacionais.</li><li>Experiência em atividades relacionadas ao ferramental de injeção plástica, tais como:</li><li>Try outs: realização de testes de moldagem com as ferramentas, verificando a qualidade e a conformidade dos produtos.</li><li>Liberação de ferramental: emissão de relatórios e documentos que atestam a aptidão das ferramentas para a produção.</li><li>Inspeção / desenvolvimento de ferramentas Soft e Hard: avaliação e aprimoramento das características técnicas e funcionais das ferramentas, tanto em estágio inicial (Soft) quanto em estágio final (Hard).</li><li>Aprovação de texturização: análise e validação da textura aplicada nas superfícies das ferramentas, de acordo com as especificações do cliente.</li><li>Validação dimensional: medição e verificação das dimensões das ferramentas e dos produtos, utilizando instrumentos de precisão e seguindo os padrões de tolerância.</li><li>Modificação de produto: execução de alterações nas ferramentas, conforme solicitação do cliente ou necessidade de melhoria do produto.</li><li>Auditorias de ferramental em injetores parceiros: inspeção e controle da qualidade das ferramentas utilizadas por empresas terceirizadas que prestam serviços de injeção plástica.</li><li>Acompanhamento de FMEA: participação na análise de modos de falha e seus efeitos, identificando e prevenindo possíveis problemas nas ferramentas e nos produtos.</li><li>Acompanhamento de testes de Moldflow: supervisão e interpretação dos resultados dos testes de simulação computacional do processo de injeção plástica, otimizando o desempenho das ferramentas.</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933713,"hash":"QVXRYW7R","position_name":"Analista de Custos(plásticos)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos com experiência e conhecimento avançado em materiais de injeção, aplicações, propriedades, testes, validação, desenvolvimento de fornecedores, modificações de produto, auditorias e propostas de VAVE.</p>\n<h4><strong>Requisitos</strong></h4>\n<ul><li>Formação superior em Engenharia de custos, Química ou áreas afins.</li><li>Conhecimento avançado em polímeros de engenharia, incluindo os custos envolvidos na sua aplicação.</li><li>Conhecimento avançado em aplicações de polímeros, incluindo os custos envolvidos na sua seleção, especificação e substituição.</li><li>Habilidades de mestre em propriedades de materiais de injeção, incluindo os custos envolvidos na sua otimização, controle e melhoria.</li><li>Habilidades de mestre para resolver problemas de polímeros no processo de injeção, incluindo os custos envolvidos na sua prevenção, detecção e correção.</li><li>Leitura, escrita e fala técnica em inglês, com capacidade de se comunicar com clientes, fornecedores e equipes internacionais.</li><li>Capaz de realizar mudanças de material e análise de fornecedores, incluindo os custos envolvidos na sua avaliação, negociação e homologação.</li><li>Habilidades de mestre em propostas de VAVE (Value Analysis and Value Engineering), incluindo os custos envolvidos na sua elaboração, apresentação e implementação.</li><li>Experiência em:</li><li>Testes de materiais, incluindo ensaios mecânicos, térmicos, ópticos, químicos e ambientais.</li><li>Validação de materiais, incluindo aprovação de cores (padrão), validação dimensional, análise de falhas e emissão de relatórios.</li><li>Desenvolvimento de fornecedores, incluindo pesquisa de mercado, prospecção, qualificação, auditoria e acompanhamento.</li><li>Modificação de produto, incluindo alterações de design, funcionalidade, desempenho e qualidade.</li><li>Auditorias de materiais em parceiros injetores, incluindo verificação de conformidade, rastreabilidade, controle de estoque e gestão de resíduos.</li><li>FMEA (Failure Mode and Effect Analysis) e acompanhamento de Moldflow (simulação de injeção).</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852358,"hash":"L8657W63","position_name":"Analista de Dados","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><li><strong>Gênero:</strong> Mulher</li><li><strong>Habilidades:</strong><ul><li>Excelente conhecimento em Excel</li><li>Iniciativa</li><li>Conhecimento intermediário ou bom em Power BI</li></ul>\n<p></p>\n<p></p></li><li><strong>Formação:</strong> Técnica</li><li><strong>Idioma:</strong> Inglês</li><li><strong>Regime de Trabalho:</strong> Hibrido / Betim</li><li><br></li><p></p>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1928936,"hash":"LR4367RX","position_name":"Analista de Dados","description":"<p><strong>Responsabilidades:</strong></p>\n<ul><li>Gerenciar o orçamento designado para projetos de engenharia, garantindo o uso eficiente dos recursos financeiros disponíveis.</li><li>Monitorar e otimizar a distribuição de trabalho entre as diferentes áreas de engenharia, assegurando a eficácia operacional e o cumprimento dos prazos.</li><li>Colaborar com as equipes de projeto para identificar áreas de melhoria e implementar soluções eficazes para aumentar a eficiência e a produtividade.</li><li>Comunicar-se de forma eficaz com diversas interfaces, incluindo equipes de engenharia, líderes de projeto e stakeholders, para alinhar expectativas e garantir o progresso consistente dos projetos.</li></ul>\n<p><strong>﻿Requisitos:</strong></p><p><strong>﻿<br></strong></p>\n<ul><li>Graduação Superior em qualquer área (não necessariamente engenharia), demonstrando sólida formação acadêmica e capacidade analítica.</li><li>Experiência prévia em funções relacionadas a PMO (Project Management Office), planejamento ou controle de projetos.</li><li>Fortes habilidades com planilhas e ferramentas de análise de dados, com capacidade para interpretar e apresentar informações de forma clara e concisa.</li><li>Excelente organização e capacidade de gerenciar múltiplas tarefas simultaneamente, mantendo um alto nível de precisão e atenção aos detalhes.</li><li>Habilidades interpessoais sólidas, capazes de cultivar relacionamentos eficazes com uma variedade de stakeholders.</li><li>Preferencialmente sexo feminino, visando a diversidade e inclusão no ambiente de trabalho.</li><li>Desejável proficiência em inglês avançado</li><li>Data management: Pbi, Automação de relatorios e ppts..</li><li>Experiência com&nbsp;﻿<strong><em>Linguagem M ( PowerQuery ) </em></strong>﻿</li></ul>\n<p></p>\n<p></p>\n<p><br>\n\n</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:32 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/
@@ -65,7 +65,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:49 GMT
+      - Tue, 30 Jul 2024 16:28:32 GMT
       Content-Type:
       - application/json
       Content-Length:
@@ -90,7 +90,7 @@ http_interactions:
     body:
       encoding: UTF-8
       string: '{"name":"PTC Group","logo":"https://manatal-backend-public-assets.s3.amazonaws.com/media/career_portal_logo_direct_upload/17de54dc-a64e-4285-8a80-c6896d54cdef_logotipo_PTCGROUP_crv_14092016-3.png","website":"https://ptcgroup.global/","description":"","facebook_url":"https://www.facebook.com/ptcgroup.global","linkedin_url":"https://www.linkedin.com/company/ptcgroup/","is_organizations_visible":false,"is_job_listing_enabled":true}'
-  recorded_at: Mon, 29 Jul 2024 09:06:49 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:32 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/
@@ -110,11 +110,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:50 GMT
+      - Tue, 30 Jul 2024 16:28:33 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '21455'
+      - '19729'
       Connection:
       - keep-alive
       Server:
@@ -135,11 +135,11 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1930649,"hash":"QVXR6YY8","position_name":"Accounts Analyst - Receivable/Payable (fluent in Swedish)","description":"<p><strong>Position: Accounts Analyst - Receivable/Payable&nbsp;(fluent in Swedish)</strong></p>\n<p><strong>Location: Aveiro, Portugal</strong></p>\n<p><br></p>\n<p>Our client is a global innovation and solutions partner, manufacturing low-emission and alternative fuel power needs. Their mission is to provide next-generation powertrain solutions as markets around the world transition to a more sustainable future.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsibilities:</strong></p>\n<p>This person will report to the Head of Accounting and will support the Accounts Receivable and/or Accounts Payable areas of our client. It is estimated that around 3,500 to 4,000 invoices will be processed each month.</p>\n<ul><li>Issuing and posting invoices for sales and general expenses</li><li>Accounting for receipts, invoices for parts purchases, and invoices for fixed assets</li><li>Bank reconciliation</li><li>Checking prices and receipts on the customer platform</li><li>Managing accounts receivable (customers and invoices) and FAR accounts (goods received/invoices not received)</li><li>Monitoring due dates and collections</li><li>Default management and negotiation with clients</li><li>Managing supplier complaints</li><li>Collaboration in reviewing credit and payment proposals</li><li>Invoice and invoice corrections</li><li>Control of receipts, generation of financial reports and IBS control</li><li>Customer service and resolving issues related to invoices and payments</li></ul>\n<p><strong><br></strong></p>\n<p><strong>﻿Requirements:</strong></p>\n<ul><li>Degree in Business Administration and Management, Economics or Business Sciences, or similar field;</li><li>Professional experience: 2 to 3 years in the field.</li><li>Languages: fluent English and Swedish required (regular communication with foreign countries); Spanish and/or Portuguese valuable.</li><li>Experience in SAP and Excel.</li><li>Be available to work in Portugal.﻿</li></ul>","country":"Sweden","state":"","city":"Stockholm","address":"","zipcode":"","location_display":"Stockholm, Sweden","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938459,"hash":"L96575V4","position_name":"AI & Computer Vision Developer","description":"<p><strong>Posição: AI &amp; Computer Vision Developer</strong><br></p>\n<p><strong></strong><strong>Localização: Guimarães (híbrido)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma empresa especialista em visão artificial, integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a <strong>automatização de processos</strong>.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p></p>\n<ul>\n <li>Aplicar técnicas em visão computacional e inteligência      artificial para construção de algoritmos e sistemas inteligentes para      aplicação nos projetos e produtos do cliente.</li>\n <li>Desenvolver software para aplicações em grande escala.</li>\n <li>Disposição para trabalhar num ambiente dinâmico e flexível.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul>\n <li>BS,      MS ou Ph.D. licenciatura em Ciência da Computação, Engenharia ou área      relacionada.</li>\n <li>+2      anos de experiência numa das seguintes áreas: visão computacional,      inteligência artificial, sistemas informáticos.</li>\n <li>Experiência      em programação em C / C++ e QT.</li>\n <li>Experiência com Halcon, OpenCV ou outra ferramenta especializada em      computer vision.</li><li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1698635,"hash":"L9V5Y99Y","position_name":"Analista de Contas a Pagar e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Pagar e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p><br>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.<br>﻿<br>﻿<strong><br>﻿Responsabilidades:</strong></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Pagar do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p>\n<ul><li>Lançamento de faturas de despesas gerais</li><li>Contabilização de faturas de compra de peças e posterior gestão de estoque</li><li>Verificação de preços na plataforma do cliente</li><li>Contabilização de faturas de ativos fixos</li><li>Lançamento de faturas FI (Débito Direto)</li><li>Gestão de contas FAR (Bens recebidos/Faturas não recebidas)</li><li>Gestão de reclamações de fornecedores</li><li>Colaboração na revisão de propostas de pagamento</li><li>Correções de fatura</li><li>Controlo da SII</li></ul>\n<p><br>﻿<strong><br>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional:&nbsp;2 a 3 anos na área.&nbsp;</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933733,"hash":"L763WY85","position_name":"Analista de Custos(ferramental)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos&nbsp;qualificado e experiente para atuar na área de ferramental de injeção plástica.</p>\n<h3>Requisitos</h3>\n<ul><li>Conhecimento avançado em ferramental de injeção plástica, incluindo os custos envolvidos na produção, manutenção e reparo das ferramentas.</li><li>Habilidades mestras em tecnologia periférica de ferramental de injeção, tais como sistemas de câmera quente, válvulas sequenciais, acionamentos hidráulicos ou pneumáticos, entre outros.</li><li>Leitura e escrita técnica em língua inglesa, para comunicação com fornecedores e clientes internacionais.</li><li>Experiência em atividades relacionadas ao ferramental de injeção plástica, tais como:</li><li>Try outs: realização de testes de moldagem com as ferramentas, verificando a qualidade e a conformidade dos produtos.</li><li>Liberação de ferramental: emissão de relatórios e documentos que atestam a aptidão das ferramentas para a produção.</li><li>Inspeção / desenvolvimento de ferramentas Soft e Hard: avaliação e aprimoramento das características técnicas e funcionais das ferramentas, tanto em estágio inicial (Soft) quanto em estágio final (Hard).</li><li>Aprovação de texturização: análise e validação da textura aplicada nas superfícies das ferramentas, de acordo com as especificações do cliente.</li><li>Validação dimensional: medição e verificação das dimensões das ferramentas e dos produtos, utilizando instrumentos de precisão e seguindo os padrões de tolerância.</li><li>Modificação de produto: execução de alterações nas ferramentas, conforme solicitação do cliente ou necessidade de melhoria do produto.</li><li>Auditorias de ferramental em injetores parceiros: inspeção e controle da qualidade das ferramentas utilizadas por empresas terceirizadas que prestam serviços de injeção plástica.</li><li>Acompanhamento de FMEA: participação na análise de modos de falha e seus efeitos, identificando e prevenindo possíveis problemas nas ferramentas e nos produtos.</li><li>Acompanhamento de testes de Moldflow: supervisão e interpretação dos resultados dos testes de simulação computacional do processo de injeção plástica, otimizando o desempenho das ferramentas.</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933713,"hash":"QVXRYW7R","position_name":"Analista de Custos(plásticos)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos com experiência e conhecimento avançado em materiais de injeção, aplicações, propriedades, testes, validação, desenvolvimento de fornecedores, modificações de produto, auditorias e propostas de VAVE.</p>\n<h4><strong>Requisitos</strong></h4>\n<ul><li>Formação superior em Engenharia de custos, Química ou áreas afins.</li><li>Conhecimento avançado em polímeros de engenharia, incluindo os custos envolvidos na sua aplicação.</li><li>Conhecimento avançado em aplicações de polímeros, incluindo os custos envolvidos na sua seleção, especificação e substituição.</li><li>Habilidades de mestre em propriedades de materiais de injeção, incluindo os custos envolvidos na sua otimização, controle e melhoria.</li><li>Habilidades de mestre para resolver problemas de polímeros no processo de injeção, incluindo os custos envolvidos na sua prevenção, detecção e correção.</li><li>Leitura, escrita e fala técnica em inglês, com capacidade de se comunicar com clientes, fornecedores e equipes internacionais.</li><li>Capaz de realizar mudanças de material e análise de fornecedores, incluindo os custos envolvidos na sua avaliação, negociação e homologação.</li><li>Habilidades de mestre em propostas de VAVE (Value Analysis and Value Engineering), incluindo os custos envolvidos na sua elaboração, apresentação e implementação.</li><li>Experiência em:</li><li>Testes de materiais, incluindo ensaios mecânicos, térmicos, ópticos, químicos e ambientais.</li><li>Validação de materiais, incluindo aprovação de cores (padrão), validação dimensional, análise de falhas e emissão de relatórios.</li><li>Desenvolvimento de fornecedores, incluindo pesquisa de mercado, prospecção, qualificação, auditoria e acompanhamento.</li><li>Modificação de produto, incluindo alterações de design, funcionalidade, desempenho e qualidade.</li><li>Auditorias de materiais em parceiros injetores, incluindo verificação de conformidade, rastreabilidade, controle de estoque e gestão de resíduos.</li><li>FMEA (Failure Mode and Effect Analysis) e acompanhamento de Moldflow (simulação de injeção).</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1928936,"hash":"LR4367RX","position_name":"Analista de Dados","description":"<p><strong>Responsabilidades:</strong></p>\n<ul><li>Gerenciar o orçamento designado para projetos de engenharia, garantindo o uso eficiente dos recursos financeiros disponíveis.</li><li>Monitorar e otimizar a distribuição de trabalho entre as diferentes áreas de engenharia, assegurando a eficácia operacional e o cumprimento dos prazos.</li><li>Colaborar com as equipes de projeto para identificar áreas de melhoria e implementar soluções eficazes para aumentar a eficiência e a produtividade.</li><li>Comunicar-se de forma eficaz com diversas interfaces, incluindo equipes de engenharia, líderes de projeto e stakeholders, para alinhar expectativas e garantir o progresso consistente dos projetos.</li></ul>\n<p><strong>﻿Requisitos:</strong></p><p><strong>﻿<br></strong></p>\n<ul><li>Graduação Superior em qualquer área (não necessariamente engenharia), demonstrando sólida formação acadêmica e capacidade analítica.</li><li>Experiência prévia em funções relacionadas a PMO (Project Management Office), planejamento ou controle de projetos.</li><li>Fortes habilidades com planilhas e ferramentas de análise de dados, com capacidade para interpretar e apresentar informações de forma clara e concisa.</li><li>Excelente organização e capacidade de gerenciar múltiplas tarefas simultaneamente, mantendo um alto nível de precisão e atenção aos detalhes.</li><li>Habilidades interpessoais sólidas, capazes de cultivar relacionamentos eficazes com uma variedade de stakeholders.</li><li>Preferencialmente sexo feminino, visando a diversidade e inclusão no ambiente de trabalho.</li><li>Desejável proficiência em inglês avançado</li><li>Data management: Pbi, Automação de relatorios e ppts..</li><li>Experiência com&nbsp;﻿<strong><em>Linguagem M ( PowerQuery ) </em></strong>﻿</li></ul>\n<p></p>\n<p></p>\n<p><br>\n\n</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852358,"hash":"L8657W63","position_name":"Analista de Dados","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><li><strong>Gênero:</strong> Mulher</li><li><strong>Habilidades:</strong><ul><li>Excelente conhecimento em Excel</li><li>Iniciativa</li><li>Conhecimento intermediário ou bom em Power BI</li></ul>\n<p></p>\n<p></p></li><li><strong>Formação:</strong> Técnica</li><li><strong>Idioma:</strong> Inglês</li><li><strong>Regime de Trabalho:</strong> Hibrido / Betim</li><li><br></li><p></p>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:50 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1930649,"hash":"QVXR6YY8","position_name":"Accounts Analyst - Receivable/Payable (fluent in Swedish)","description":"<p><strong>Position: Accounts Analyst - Receivable/Payable&nbsp;(fluent in Swedish)</strong></p>\n<p><strong>Location: Aveiro, Portugal</strong></p>\n<p><br></p>\n<p>Our client is a global innovation and solutions partner, manufacturing low-emission and alternative fuel power needs. Their mission is to provide next-generation powertrain solutions as markets around the world transition to a more sustainable future.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsibilities:</strong></p>\n<p>This person will report to the Head of Accounting and will support the Accounts Receivable and/or Accounts Payable areas of our client. It is estimated that around 3,500 to 4,000 invoices will be processed each month.</p>\n<ul><li>Issuing and posting invoices for sales and general expenses</li><li>Accounting for receipts, invoices for parts purchases, and invoices for fixed assets</li><li>Bank reconciliation</li><li>Checking prices and receipts on the customer platform</li><li>Managing accounts receivable (customers and invoices) and FAR accounts (goods received/invoices not received)</li><li>Monitoring due dates and collections</li><li>Default management and negotiation with clients</li><li>Managing supplier complaints</li><li>Collaboration in reviewing credit and payment proposals</li><li>Invoice and invoice corrections</li><li>Control of receipts, generation of financial reports and IBS control</li><li>Customer service and resolving issues related to invoices and payments</li></ul>\n<p><strong><br></strong></p>\n<p><strong>﻿Requirements:</strong></p>\n<ul><li>Degree in Business Administration and Management, Economics or Business Sciences, or similar field;</li><li>Professional experience: 2 to 3 years in the field.</li><li>Languages: fluent English and Swedish required (regular communication with foreign countries); Spanish and/or Portuguese valuable.</li><li>Experience in SAP and Excel.</li><li>Be available to work in Portugal.﻿</li></ul>","country":"Sweden","state":"","city":"Stockholm","address":"","zipcode":"","location_display":"Stockholm, Sweden","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965495,"hash":"L96W5744","position_name":"AGCO - Almoxarife (reposição)","description":"<p>Almoxarife, com certificação em NR11, para atuar presencialmente em Mogi das Cruzes, horário administrativo&nbsp;</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938459,"hash":"L96575V4","position_name":"AI & Computer Vision Developer","description":"<p><strong>Posição: AI &amp; Computer Vision Developer</strong><br></p>\n<p><strong></strong><strong>Localização: Guimarães (híbrido)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma empresa especialista em visão artificial, integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a <strong>automatização de processos</strong>.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p></p>\n<ul>\n <li>Aplicar técnicas em visão computacional e inteligência      artificial para construção de algoritmos e sistemas inteligentes para      aplicação nos projetos e produtos do cliente.</li>\n <li>Desenvolver software para aplicações em grande escala.</li>\n <li>Disposição para trabalhar num ambiente dinâmico e flexível.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul>\n <li>BS,      MS ou Ph.D. licenciatura em Ciência da Computação, Engenharia ou área      relacionada.</li>\n <li>+2      anos de experiência numa das seguintes áreas: visão computacional,      inteligência artificial, sistemas informáticos.</li>\n <li>Experiência      em programação em C / C++ e QT.</li>\n <li>Experiência com Halcon, OpenCV ou outra ferramenta especializada em      computer vision.</li><li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933733,"hash":"L763WY85","position_name":"Analista de Custos(ferramental)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos&nbsp;qualificado e experiente para atuar na área de ferramental de injeção plástica.</p>\n<h3>Requisitos</h3>\n<ul><li>Conhecimento avançado em ferramental de injeção plástica, incluindo os custos envolvidos na produção, manutenção e reparo das ferramentas.</li><li>Habilidades mestras em tecnologia periférica de ferramental de injeção, tais como sistemas de câmera quente, válvulas sequenciais, acionamentos hidráulicos ou pneumáticos, entre outros.</li><li>Leitura e escrita técnica em língua inglesa, para comunicação com fornecedores e clientes internacionais.</li><li>Experiência em atividades relacionadas ao ferramental de injeção plástica, tais como:</li><li>Try outs: realização de testes de moldagem com as ferramentas, verificando a qualidade e a conformidade dos produtos.</li><li>Liberação de ferramental: emissão de relatórios e documentos que atestam a aptidão das ferramentas para a produção.</li><li>Inspeção / desenvolvimento de ferramentas Soft e Hard: avaliação e aprimoramento das características técnicas e funcionais das ferramentas, tanto em estágio inicial (Soft) quanto em estágio final (Hard).</li><li>Aprovação de texturização: análise e validação da textura aplicada nas superfícies das ferramentas, de acordo com as especificações do cliente.</li><li>Validação dimensional: medição e verificação das dimensões das ferramentas e dos produtos, utilizando instrumentos de precisão e seguindo os padrões de tolerância.</li><li>Modificação de produto: execução de alterações nas ferramentas, conforme solicitação do cliente ou necessidade de melhoria do produto.</li><li>Auditorias de ferramental em injetores parceiros: inspeção e controle da qualidade das ferramentas utilizadas por empresas terceirizadas que prestam serviços de injeção plástica.</li><li>Acompanhamento de FMEA: participação na análise de modos de falha e seus efeitos, identificando e prevenindo possíveis problemas nas ferramentas e nos produtos.</li><li>Acompanhamento de testes de Moldflow: supervisão e interpretação dos resultados dos testes de simulação computacional do processo de injeção plástica, otimizando o desempenho das ferramentas.</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933713,"hash":"QVXRYW7R","position_name":"Analista de Custos(plásticos)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos com experiência e conhecimento avançado em materiais de injeção, aplicações, propriedades, testes, validação, desenvolvimento de fornecedores, modificações de produto, auditorias e propostas de VAVE.</p>\n<h4><strong>Requisitos</strong></h4>\n<ul><li>Formação superior em Engenharia de custos, Química ou áreas afins.</li><li>Conhecimento avançado em polímeros de engenharia, incluindo os custos envolvidos na sua aplicação.</li><li>Conhecimento avançado em aplicações de polímeros, incluindo os custos envolvidos na sua seleção, especificação e substituição.</li><li>Habilidades de mestre em propriedades de materiais de injeção, incluindo os custos envolvidos na sua otimização, controle e melhoria.</li><li>Habilidades de mestre para resolver problemas de polímeros no processo de injeção, incluindo os custos envolvidos na sua prevenção, detecção e correção.</li><li>Leitura, escrita e fala técnica em inglês, com capacidade de se comunicar com clientes, fornecedores e equipes internacionais.</li><li>Capaz de realizar mudanças de material e análise de fornecedores, incluindo os custos envolvidos na sua avaliação, negociação e homologação.</li><li>Habilidades de mestre em propostas de VAVE (Value Analysis and Value Engineering), incluindo os custos envolvidos na sua elaboração, apresentação e implementação.</li><li>Experiência em:</li><li>Testes de materiais, incluindo ensaios mecânicos, térmicos, ópticos, químicos e ambientais.</li><li>Validação de materiais, incluindo aprovação de cores (padrão), validação dimensional, análise de falhas e emissão de relatórios.</li><li>Desenvolvimento de fornecedores, incluindo pesquisa de mercado, prospecção, qualificação, auditoria e acompanhamento.</li><li>Modificação de produto, incluindo alterações de design, funcionalidade, desempenho e qualidade.</li><li>Auditorias de materiais em parceiros injetores, incluindo verificação de conformidade, rastreabilidade, controle de estoque e gestão de resíduos.</li><li>FMEA (Failure Mode and Effect Analysis) e acompanhamento de Moldflow (simulação de injeção).</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852358,"hash":"L8657W63","position_name":"Analista de Dados","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><li><strong>Gênero:</strong> Mulher</li><li><strong>Habilidades:</strong><ul><li>Excelente conhecimento em Excel</li><li>Iniciativa</li><li>Conhecimento intermediário ou bom em Power BI</li></ul>\n<p></p>\n<p></p></li><li><strong>Formação:</strong> Técnica</li><li><strong>Idioma:</strong> Inglês</li><li><strong>Regime de Trabalho:</strong> Hibrido / Betim</li><li><br></li><p></p>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1928936,"hash":"LR4367RX","position_name":"Analista de Dados","description":"<p><strong>Responsabilidades:</strong></p>\n<ul><li>Gerenciar o orçamento designado para projetos de engenharia, garantindo o uso eficiente dos recursos financeiros disponíveis.</li><li>Monitorar e otimizar a distribuição de trabalho entre as diferentes áreas de engenharia, assegurando a eficácia operacional e o cumprimento dos prazos.</li><li>Colaborar com as equipes de projeto para identificar áreas de melhoria e implementar soluções eficazes para aumentar a eficiência e a produtividade.</li><li>Comunicar-se de forma eficaz com diversas interfaces, incluindo equipes de engenharia, líderes de projeto e stakeholders, para alinhar expectativas e garantir o progresso consistente dos projetos.</li></ul>\n<p><strong>﻿Requisitos:</strong></p><p><strong>﻿<br></strong></p>\n<ul><li>Graduação Superior em qualquer área (não necessariamente engenharia), demonstrando sólida formação acadêmica e capacidade analítica.</li><li>Experiência prévia em funções relacionadas a PMO (Project Management Office), planejamento ou controle de projetos.</li><li>Fortes habilidades com planilhas e ferramentas de análise de dados, com capacidade para interpretar e apresentar informações de forma clara e concisa.</li><li>Excelente organização e capacidade de gerenciar múltiplas tarefas simultaneamente, mantendo um alto nível de precisão e atenção aos detalhes.</li><li>Habilidades interpessoais sólidas, capazes de cultivar relacionamentos eficazes com uma variedade de stakeholders.</li><li>Preferencialmente sexo feminino, visando a diversidade e inclusão no ambiente de trabalho.</li><li>Desejável proficiência em inglês avançado</li><li>Data management: Pbi, Automação de relatorios e ppts..</li><li>Experiência com&nbsp;﻿<strong><em>Linguagem M ( PowerQuery ) </em></strong>﻿</li></ul>\n<p></p>\n<p></p>\n<p><br>\n\n</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:33 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://ptcgroup.global/"]}],"limit":1}'
@@ -162,9 +162,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:06:50 GMT
+      - Tue, 30 Jul 2024 16:28:33 GMT
       Etag:
-      - W/"1722244010937"
+      - W/"1722356913902"
       Server:
       - openresty
       X-Cb-Engine:
@@ -176,11 +176,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '37'
+      - '5'
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '48'
+      - '13'
       Content-Length:
       - '538'
       Connection:
@@ -191,8 +191,8 @@ http_interactions:
         Group","identifier":{"permalink":"ptc-group-9de5","image_id":"szydmwyma8qxx3umkpqw","uuid":"b334425c-0d5a-4a43-8fde-11360ea69de5","entity_def_id":"organization","value":"PTC
         Group"},"linkedin":{"value":"https://www.linkedin.com/company/ptcgroup/"},"short_description":"PTC
         Group is an IT company that provides engineering, design, training, recruitment,
-        and consulting services.","rank_org":438663,"website_url":"https://ptcgroup.global/"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:06:50 GMT
+        and consulting services.","rank_org":443043,"website_url":"https://ptcgroup.global/"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:33 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=1
@@ -212,11 +212,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:51 GMT
+      - Tue, 30 Jul 2024 16:28:34 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '21455'
+      - '19729'
       Connection:
       - keep-alive
       Server:
@@ -237,8 +237,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1930649,"hash":"QVXR6YY8","position_name":"Accounts Analyst - Receivable/Payable (fluent in Swedish)","description":"<p><strong>Position: Accounts Analyst - Receivable/Payable&nbsp;(fluent in Swedish)</strong></p>\n<p><strong>Location: Aveiro, Portugal</strong></p>\n<p><br></p>\n<p>Our client is a global innovation and solutions partner, manufacturing low-emission and alternative fuel power needs. Their mission is to provide next-generation powertrain solutions as markets around the world transition to a more sustainable future.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsibilities:</strong></p>\n<p>This person will report to the Head of Accounting and will support the Accounts Receivable and/or Accounts Payable areas of our client. It is estimated that around 3,500 to 4,000 invoices will be processed each month.</p>\n<ul><li>Issuing and posting invoices for sales and general expenses</li><li>Accounting for receipts, invoices for parts purchases, and invoices for fixed assets</li><li>Bank reconciliation</li><li>Checking prices and receipts on the customer platform</li><li>Managing accounts receivable (customers and invoices) and FAR accounts (goods received/invoices not received)</li><li>Monitoring due dates and collections</li><li>Default management and negotiation with clients</li><li>Managing supplier complaints</li><li>Collaboration in reviewing credit and payment proposals</li><li>Invoice and invoice corrections</li><li>Control of receipts, generation of financial reports and IBS control</li><li>Customer service and resolving issues related to invoices and payments</li></ul>\n<p><strong><br></strong></p>\n<p><strong>﻿Requirements:</strong></p>\n<ul><li>Degree in Business Administration and Management, Economics or Business Sciences, or similar field;</li><li>Professional experience: 2 to 3 years in the field.</li><li>Languages: fluent English and Swedish required (regular communication with foreign countries); Spanish and/or Portuguese valuable.</li><li>Experience in SAP and Excel.</li><li>Be available to work in Portugal.﻿</li></ul>","country":"Sweden","state":"","city":"Stockholm","address":"","zipcode":"","location_display":"Stockholm, Sweden","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938459,"hash":"L96575V4","position_name":"AI & Computer Vision Developer","description":"<p><strong>Posição: AI &amp; Computer Vision Developer</strong><br></p>\n<p><strong></strong><strong>Localização: Guimarães (híbrido)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma empresa especialista em visão artificial, integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a <strong>automatização de processos</strong>.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p></p>\n<ul>\n <li>Aplicar técnicas em visão computacional e inteligência      artificial para construção de algoritmos e sistemas inteligentes para      aplicação nos projetos e produtos do cliente.</li>\n <li>Desenvolver software para aplicações em grande escala.</li>\n <li>Disposição para trabalhar num ambiente dinâmico e flexível.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul>\n <li>BS,      MS ou Ph.D. licenciatura em Ciência da Computação, Engenharia ou área      relacionada.</li>\n <li>+2      anos de experiência numa das seguintes áreas: visão computacional,      inteligência artificial, sistemas informáticos.</li>\n <li>Experiência      em programação em C / C++ e QT.</li>\n <li>Experiência com Halcon, OpenCV ou outra ferramenta especializada em      computer vision.</li><li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1698635,"hash":"L9V5Y99Y","position_name":"Analista de Contas a Pagar e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Pagar e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p><br>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.<br>﻿<br>﻿<strong><br>﻿Responsabilidades:</strong></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Pagar do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p>\n<ul><li>Lançamento de faturas de despesas gerais</li><li>Contabilização de faturas de compra de peças e posterior gestão de estoque</li><li>Verificação de preços na plataforma do cliente</li><li>Contabilização de faturas de ativos fixos</li><li>Lançamento de faturas FI (Débito Direto)</li><li>Gestão de contas FAR (Bens recebidos/Faturas não recebidas)</li><li>Gestão de reclamações de fornecedores</li><li>Colaboração na revisão de propostas de pagamento</li><li>Correções de fatura</li><li>Controlo da SII</li></ul>\n<p><br>﻿<strong><br>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional:&nbsp;2 a 3 anos na área.&nbsp;</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933733,"hash":"L763WY85","position_name":"Analista de Custos(ferramental)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos&nbsp;qualificado e experiente para atuar na área de ferramental de injeção plástica.</p>\n<h3>Requisitos</h3>\n<ul><li>Conhecimento avançado em ferramental de injeção plástica, incluindo os custos envolvidos na produção, manutenção e reparo das ferramentas.</li><li>Habilidades mestras em tecnologia periférica de ferramental de injeção, tais como sistemas de câmera quente, válvulas sequenciais, acionamentos hidráulicos ou pneumáticos, entre outros.</li><li>Leitura e escrita técnica em língua inglesa, para comunicação com fornecedores e clientes internacionais.</li><li>Experiência em atividades relacionadas ao ferramental de injeção plástica, tais como:</li><li>Try outs: realização de testes de moldagem com as ferramentas, verificando a qualidade e a conformidade dos produtos.</li><li>Liberação de ferramental: emissão de relatórios e documentos que atestam a aptidão das ferramentas para a produção.</li><li>Inspeção / desenvolvimento de ferramentas Soft e Hard: avaliação e aprimoramento das características técnicas e funcionais das ferramentas, tanto em estágio inicial (Soft) quanto em estágio final (Hard).</li><li>Aprovação de texturização: análise e validação da textura aplicada nas superfícies das ferramentas, de acordo com as especificações do cliente.</li><li>Validação dimensional: medição e verificação das dimensões das ferramentas e dos produtos, utilizando instrumentos de precisão e seguindo os padrões de tolerância.</li><li>Modificação de produto: execução de alterações nas ferramentas, conforme solicitação do cliente ou necessidade de melhoria do produto.</li><li>Auditorias de ferramental em injetores parceiros: inspeção e controle da qualidade das ferramentas utilizadas por empresas terceirizadas que prestam serviços de injeção plástica.</li><li>Acompanhamento de FMEA: participação na análise de modos de falha e seus efeitos, identificando e prevenindo possíveis problemas nas ferramentas e nos produtos.</li><li>Acompanhamento de testes de Moldflow: supervisão e interpretação dos resultados dos testes de simulação computacional do processo de injeção plástica, otimizando o desempenho das ferramentas.</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933713,"hash":"QVXRYW7R","position_name":"Analista de Custos(plásticos)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos com experiência e conhecimento avançado em materiais de injeção, aplicações, propriedades, testes, validação, desenvolvimento de fornecedores, modificações de produto, auditorias e propostas de VAVE.</p>\n<h4><strong>Requisitos</strong></h4>\n<ul><li>Formação superior em Engenharia de custos, Química ou áreas afins.</li><li>Conhecimento avançado em polímeros de engenharia, incluindo os custos envolvidos na sua aplicação.</li><li>Conhecimento avançado em aplicações de polímeros, incluindo os custos envolvidos na sua seleção, especificação e substituição.</li><li>Habilidades de mestre em propriedades de materiais de injeção, incluindo os custos envolvidos na sua otimização, controle e melhoria.</li><li>Habilidades de mestre para resolver problemas de polímeros no processo de injeção, incluindo os custos envolvidos na sua prevenção, detecção e correção.</li><li>Leitura, escrita e fala técnica em inglês, com capacidade de se comunicar com clientes, fornecedores e equipes internacionais.</li><li>Capaz de realizar mudanças de material e análise de fornecedores, incluindo os custos envolvidos na sua avaliação, negociação e homologação.</li><li>Habilidades de mestre em propostas de VAVE (Value Analysis and Value Engineering), incluindo os custos envolvidos na sua elaboração, apresentação e implementação.</li><li>Experiência em:</li><li>Testes de materiais, incluindo ensaios mecânicos, térmicos, ópticos, químicos e ambientais.</li><li>Validação de materiais, incluindo aprovação de cores (padrão), validação dimensional, análise de falhas e emissão de relatórios.</li><li>Desenvolvimento de fornecedores, incluindo pesquisa de mercado, prospecção, qualificação, auditoria e acompanhamento.</li><li>Modificação de produto, incluindo alterações de design, funcionalidade, desempenho e qualidade.</li><li>Auditorias de materiais em parceiros injetores, incluindo verificação de conformidade, rastreabilidade, controle de estoque e gestão de resíduos.</li><li>FMEA (Failure Mode and Effect Analysis) e acompanhamento de Moldflow (simulação de injeção).</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1928936,"hash":"LR4367RX","position_name":"Analista de Dados","description":"<p><strong>Responsabilidades:</strong></p>\n<ul><li>Gerenciar o orçamento designado para projetos de engenharia, garantindo o uso eficiente dos recursos financeiros disponíveis.</li><li>Monitorar e otimizar a distribuição de trabalho entre as diferentes áreas de engenharia, assegurando a eficácia operacional e o cumprimento dos prazos.</li><li>Colaborar com as equipes de projeto para identificar áreas de melhoria e implementar soluções eficazes para aumentar a eficiência e a produtividade.</li><li>Comunicar-se de forma eficaz com diversas interfaces, incluindo equipes de engenharia, líderes de projeto e stakeholders, para alinhar expectativas e garantir o progresso consistente dos projetos.</li></ul>\n<p><strong>﻿Requisitos:</strong></p><p><strong>﻿<br></strong></p>\n<ul><li>Graduação Superior em qualquer área (não necessariamente engenharia), demonstrando sólida formação acadêmica e capacidade analítica.</li><li>Experiência prévia em funções relacionadas a PMO (Project Management Office), planejamento ou controle de projetos.</li><li>Fortes habilidades com planilhas e ferramentas de análise de dados, com capacidade para interpretar e apresentar informações de forma clara e concisa.</li><li>Excelente organização e capacidade de gerenciar múltiplas tarefas simultaneamente, mantendo um alto nível de precisão e atenção aos detalhes.</li><li>Habilidades interpessoais sólidas, capazes de cultivar relacionamentos eficazes com uma variedade de stakeholders.</li><li>Preferencialmente sexo feminino, visando a diversidade e inclusão no ambiente de trabalho.</li><li>Desejável proficiência em inglês avançado</li><li>Data management: Pbi, Automação de relatorios e ppts..</li><li>Experiência com&nbsp;﻿<strong><em>Linguagem M ( PowerQuery ) </em></strong>﻿</li></ul>\n<p></p>\n<p></p>\n<p><br>\n\n</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852358,"hash":"L8657W63","position_name":"Analista de Dados","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><li><strong>Gênero:</strong> Mulher</li><li><strong>Habilidades:</strong><ul><li>Excelente conhecimento em Excel</li><li>Iniciativa</li><li>Conhecimento intermediário ou bom em Power BI</li></ul>\n<p></p>\n<p></p></li><li><strong>Formação:</strong> Técnica</li><li><strong>Idioma:</strong> Inglês</li><li><strong>Regime de Trabalho:</strong> Hibrido / Betim</li><li><br></li><p></p>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:51 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","previous":null,"results":[{"id":1930649,"hash":"QVXR6YY8","position_name":"Accounts Analyst - Receivable/Payable (fluent in Swedish)","description":"<p><strong>Position: Accounts Analyst - Receivable/Payable&nbsp;(fluent in Swedish)</strong></p>\n<p><strong>Location: Aveiro, Portugal</strong></p>\n<p><br></p>\n<p>Our client is a global innovation and solutions partner, manufacturing low-emission and alternative fuel power needs. Their mission is to provide next-generation powertrain solutions as markets around the world transition to a more sustainable future.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsibilities:</strong></p>\n<p>This person will report to the Head of Accounting and will support the Accounts Receivable and/or Accounts Payable areas of our client. It is estimated that around 3,500 to 4,000 invoices will be processed each month.</p>\n<ul><li>Issuing and posting invoices for sales and general expenses</li><li>Accounting for receipts, invoices for parts purchases, and invoices for fixed assets</li><li>Bank reconciliation</li><li>Checking prices and receipts on the customer platform</li><li>Managing accounts receivable (customers and invoices) and FAR accounts (goods received/invoices not received)</li><li>Monitoring due dates and collections</li><li>Default management and negotiation with clients</li><li>Managing supplier complaints</li><li>Collaboration in reviewing credit and payment proposals</li><li>Invoice and invoice corrections</li><li>Control of receipts, generation of financial reports and IBS control</li><li>Customer service and resolving issues related to invoices and payments</li></ul>\n<p><strong><br></strong></p>\n<p><strong>﻿Requirements:</strong></p>\n<ul><li>Degree in Business Administration and Management, Economics or Business Sciences, or similar field;</li><li>Professional experience: 2 to 3 years in the field.</li><li>Languages: fluent English and Swedish required (regular communication with foreign countries); Spanish and/or Portuguese valuable.</li><li>Experience in SAP and Excel.</li><li>Be available to work in Portugal.﻿</li></ul>","country":"Sweden","state":"","city":"Stockholm","address":"","zipcode":"","location_display":"Stockholm, Sweden","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965495,"hash":"L96W5744","position_name":"AGCO - Almoxarife (reposição)","description":"<p>Almoxarife, com certificação em NR11, para atuar presencialmente em Mogi das Cruzes, horário administrativo&nbsp;</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938459,"hash":"L96575V4","position_name":"AI & Computer Vision Developer","description":"<p><strong>Posição: AI &amp; Computer Vision Developer</strong><br></p>\n<p><strong></strong><strong>Localização: Guimarães (híbrido)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma empresa especialista em visão artificial, integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a <strong>automatização de processos</strong>.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p></p>\n<ul>\n <li>Aplicar técnicas em visão computacional e inteligência      artificial para construção de algoritmos e sistemas inteligentes para      aplicação nos projetos e produtos do cliente.</li>\n <li>Desenvolver software para aplicações em grande escala.</li>\n <li>Disposição para trabalhar num ambiente dinâmico e flexível.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul>\n <li>BS,      MS ou Ph.D. licenciatura em Ciência da Computação, Engenharia ou área      relacionada.</li>\n <li>+2      anos de experiência numa das seguintes áreas: visão computacional,      inteligência artificial, sistemas informáticos.</li>\n <li>Experiência      em programação em C / C++ e QT.</li>\n <li>Experiência com Halcon, OpenCV ou outra ferramenta especializada em      computer vision.</li><li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1800323,"hash":"L96R5WRY","position_name":"Almoxarife com NR20 (abastecimento)","description":"<ul><li>Recebimento e movimentação de peças protótipos e de produção com empilhadeira</li><li>abastecimento de veículos</li><li>Quando solicitados, encaminham vasilhames e tambores aprovados pela segurança do trabalho para enchimento na SUT</li><li>Controle de entradas e saídas do estoque via JDE</li><li>Buscar peças e materiais que sejam necessários na linha de produção e no recebimento da fábrica;</li><li>Principais equipamentos para operar: empilhadeira, paleteira</li><li>Conferir peças recebidas (quantidade recebida Vs. Nota fiscal)</li><li>Lançamento no sistema</li><li>Alocar material no estoque</li><li>Realizar inventário de produtos</li><li>Planejamento de materiais, provendo informações e Reports utilizando SAP, MS Excel e MS PowerPoint</li></ul>\n<p>Requisitos:<br>certificação NR20 (abastecimento)</p><p>Certificação NR11 para operação de empilhadeira<br>Conhecimentos em sistema de operação de almoxarifado<br>Conhecimento em pacote Office e experiência comprovada﻿</p>","country":"Brazil","state":"SP","city":"Mogi das Cruzes","address":"","zipcode":"","location_display":"Mogi das Cruzes, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1788806,"hash":"L4YV8V8V","position_name":"Analista de Contas a Receber e Contabilidade","description":"<p><strong>Vaga: Analista de Contas a Receber e Contabilidade</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿Responsabilidades:</strong></span></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p><ul><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Emissão e lançamento de faturas de vendas</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Contabilização de recebimentos e conciliação bancária</li><li>Verificação de recebimentos na plataforma do cliente</li><li>Gestão de contas a receber (clientes e notas fiscais)</li><li>Monitorização de vencimentos e cobranças</li><li>Gestão de inadimplências e negociação com clientes</li><li>Colaboração na revisão de propostas de crédito</li><li>Correções de faturas e notas fiscais</li><li>Controlo de recebimentos e geração de relatórios financeiros</li><li>Atendimento a clientes e resolução de questões relacionadas a faturas e pagamentos</li></ul>\n<p>﻿</p>\n<p><strong>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura em Administração e Gestão de Empresas, Ciências Económicas ou Empresariais;</li><li>Experiência profissional: 2 a 3 anos na área.</li><li>Idiomas: Inglês obrigatório (comunicação regular com países estrangeiros); valioso espanhol ou português.</li><li>Experiência em SAP R/3 e Excel.</li><li>Trabalho presencial em Aveiro mas ter disponibilidade para viajar a Valladolid e Madrid (deslocações esporádicas).</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1766072,"hash":"LR4YV6RX","position_name":"Analista de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Empresa do ramo automotivo.</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Construção de custos (cost breakdown de preço de peças e ferramentais)</font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Gestão de custos (construção de previsões, acompanhamento de evoluções, identificação de risco de derivas, atuação na mitigação dos riscos)</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Habilidade para reporting para alta gerência</font></font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Inglês - avançado</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência prévia na função de 5 anos ou mais</font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">- Experiência no setor automotivo é um diferencial</font></font></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CLT</font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933733,"hash":"L763WY85","position_name":"Analista de Custos(ferramental)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos&nbsp;qualificado e experiente para atuar na área de ferramental de injeção plástica.</p>\n<h3>Requisitos</h3>\n<ul><li>Conhecimento avançado em ferramental de injeção plástica, incluindo os custos envolvidos na produção, manutenção e reparo das ferramentas.</li><li>Habilidades mestras em tecnologia periférica de ferramental de injeção, tais como sistemas de câmera quente, válvulas sequenciais, acionamentos hidráulicos ou pneumáticos, entre outros.</li><li>Leitura e escrita técnica em língua inglesa, para comunicação com fornecedores e clientes internacionais.</li><li>Experiência em atividades relacionadas ao ferramental de injeção plástica, tais como:</li><li>Try outs: realização de testes de moldagem com as ferramentas, verificando a qualidade e a conformidade dos produtos.</li><li>Liberação de ferramental: emissão de relatórios e documentos que atestam a aptidão das ferramentas para a produção.</li><li>Inspeção / desenvolvimento de ferramentas Soft e Hard: avaliação e aprimoramento das características técnicas e funcionais das ferramentas, tanto em estágio inicial (Soft) quanto em estágio final (Hard).</li><li>Aprovação de texturização: análise e validação da textura aplicada nas superfícies das ferramentas, de acordo com as especificações do cliente.</li><li>Validação dimensional: medição e verificação das dimensões das ferramentas e dos produtos, utilizando instrumentos de precisão e seguindo os padrões de tolerância.</li><li>Modificação de produto: execução de alterações nas ferramentas, conforme solicitação do cliente ou necessidade de melhoria do produto.</li><li>Auditorias de ferramental em injetores parceiros: inspeção e controle da qualidade das ferramentas utilizadas por empresas terceirizadas que prestam serviços de injeção plástica.</li><li>Acompanhamento de FMEA: participação na análise de modos de falha e seus efeitos, identificando e prevenindo possíveis problemas nas ferramentas e nos produtos.</li><li>Acompanhamento de testes de Moldflow: supervisão e interpretação dos resultados dos testes de simulação computacional do processo de injeção plástica, otimizando o desempenho das ferramentas.</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933713,"hash":"QVXRYW7R","position_name":"Analista de Custos(plásticos)","description":"<p>Empresa multinacional do setor automotivo está buscando um Analista de Custos com experiência e conhecimento avançado em materiais de injeção, aplicações, propriedades, testes, validação, desenvolvimento de fornecedores, modificações de produto, auditorias e propostas de VAVE.</p>\n<h4><strong>Requisitos</strong></h4>\n<ul><li>Formação superior em Engenharia de custos, Química ou áreas afins.</li><li>Conhecimento avançado em polímeros de engenharia, incluindo os custos envolvidos na sua aplicação.</li><li>Conhecimento avançado em aplicações de polímeros, incluindo os custos envolvidos na sua seleção, especificação e substituição.</li><li>Habilidades de mestre em propriedades de materiais de injeção, incluindo os custos envolvidos na sua otimização, controle e melhoria.</li><li>Habilidades de mestre para resolver problemas de polímeros no processo de injeção, incluindo os custos envolvidos na sua prevenção, detecção e correção.</li><li>Leitura, escrita e fala técnica em inglês, com capacidade de se comunicar com clientes, fornecedores e equipes internacionais.</li><li>Capaz de realizar mudanças de material e análise de fornecedores, incluindo os custos envolvidos na sua avaliação, negociação e homologação.</li><li>Habilidades de mestre em propostas de VAVE (Value Analysis and Value Engineering), incluindo os custos envolvidos na sua elaboração, apresentação e implementação.</li><li>Experiência em:</li><li>Testes de materiais, incluindo ensaios mecânicos, térmicos, ópticos, químicos e ambientais.</li><li>Validação de materiais, incluindo aprovação de cores (padrão), validação dimensional, análise de falhas e emissão de relatórios.</li><li>Desenvolvimento de fornecedores, incluindo pesquisa de mercado, prospecção, qualificação, auditoria e acompanhamento.</li><li>Modificação de produto, incluindo alterações de design, funcionalidade, desempenho e qualidade.</li><li>Auditorias de materiais em parceiros injetores, incluindo verificação de conformidade, rastreabilidade, controle de estoque e gestão de resíduos.</li><li>FMEA (Failure Mode and Effect Analysis) e acompanhamento de Moldflow (simulação de injeção).</li></ul>","country":"Brazil","state":"State of São Paulo","city":"Piracicaba","address":"","zipcode":"","location_display":"Piracicaba, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852358,"hash":"L8657W63","position_name":"Analista de Dados","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><li><strong>Gênero:</strong> Mulher</li><li><strong>Habilidades:</strong><ul><li>Excelente conhecimento em Excel</li><li>Iniciativa</li><li>Conhecimento intermediário ou bom em Power BI</li></ul>\n<p></p>\n<p></p></li><li><strong>Formação:</strong> Técnica</li><li><strong>Idioma:</strong> Inglês</li><li><strong>Regime de Trabalho:</strong> Hibrido / Betim</li><li><br></li><p></p>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1928936,"hash":"LR4367RX","position_name":"Analista de Dados","description":"<p><strong>Responsabilidades:</strong></p>\n<ul><li>Gerenciar o orçamento designado para projetos de engenharia, garantindo o uso eficiente dos recursos financeiros disponíveis.</li><li>Monitorar e otimizar a distribuição de trabalho entre as diferentes áreas de engenharia, assegurando a eficácia operacional e o cumprimento dos prazos.</li><li>Colaborar com as equipes de projeto para identificar áreas de melhoria e implementar soluções eficazes para aumentar a eficiência e a produtividade.</li><li>Comunicar-se de forma eficaz com diversas interfaces, incluindo equipes de engenharia, líderes de projeto e stakeholders, para alinhar expectativas e garantir o progresso consistente dos projetos.</li></ul>\n<p><strong>﻿Requisitos:</strong></p><p><strong>﻿<br></strong></p>\n<ul><li>Graduação Superior em qualquer área (não necessariamente engenharia), demonstrando sólida formação acadêmica e capacidade analítica.</li><li>Experiência prévia em funções relacionadas a PMO (Project Management Office), planejamento ou controle de projetos.</li><li>Fortes habilidades com planilhas e ferramentas de análise de dados, com capacidade para interpretar e apresentar informações de forma clara e concisa.</li><li>Excelente organização e capacidade de gerenciar múltiplas tarefas simultaneamente, mantendo um alto nível de precisão e atenção aos detalhes.</li><li>Habilidades interpessoais sólidas, capazes de cultivar relacionamentos eficazes com uma variedade de stakeholders.</li><li>Preferencialmente sexo feminino, visando a diversidade e inclusão no ambiente de trabalho.</li><li>Desejável proficiência em inglês avançado</li><li>Data management: Pbi, Automação de relatorios e ppts..</li><li>Experiência com&nbsp;﻿<strong><em>Linguagem M ( PowerQuery ) </em></strong>﻿</li></ul>\n<p></p>\n<p></p>\n<p><br>\n\n</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:34 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2
@@ -258,7 +258,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:51 GMT
+      - Tue, 30 Jul 2024 16:28:35 GMT
       Content-Type:
       - application/json
       Content-Length:
@@ -283,8 +283,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=3","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/","results":[{"id":1729118,"hash":"L4736YWV","position_name":"Analista de Engenharia de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">RESPONSABILIDADES DO CARGO/ ATIVIDADES A DESENVOLVER:</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Suporte para o monitoramento de Custo Total do Produto (TPC) e Ferramental do Fornecedor&nbsp;de veículos em desenvolvimento</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Execução de planilhas de monitoramento</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Garantia da precisão e alinhamento dos números que compõe o TPC e VT, interagindo com as áreas envolvidas.</font></font><br>﻿<br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿DESAFIOS DA POSIÇÃO:</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Compreensão dos inputs de trabalho (escopo técnico / prazos / perímetrtos)</font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿Integração com as áreas envolvidas no TPC para sincronismo e robustez das informações Gestão do tempo.</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CONHECIMENTOS TÉCNICO / IDIOMAS / INFORMÁTICA:</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Gerenciamento de projeto: médio</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento de processos de desenvolvimento de produtos automotivos: médio</font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿Conhecimento em custos ou finanças: alto</font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿﻿Inglês: avançado </font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿Microsoft office: avançado</font></font></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716644,"hash":"L689Y635","position_name":"Analista de IA - PL","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Analista de Inteligência Artificial (IA) Pleno desempenha um papel central na equipe de pesquisa, sendo responsável por pesquisar, desenvolver e implementar soluções inovadoras de algoritmos para problemas complexos utilizando técnicas de inteligência artificial. Este profissional possui experiência sólida em criação de datasets, treinamento de redes neurais, concepção de algoritmos, avaliação de desempenho, com foco tanto em dados discretos quanto em imagens e vídeos.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Pesquisa e Desenvolvimento de Algoritmos: Conduzir pesquisa constante para identificar e implementar algoritmos avançados de inteligência artificial para resolver problemas específicos.</p>\n<p>Criação de Datasets: Desenvolver e criar datasets anotados para treinamento e validação de redes neurais, garantindo a representação adequada dos dados.</p>\n<p>Composição de Algoritmos: Desenvolver algoritmos e modelos de IA combinando diferentes técnicas para otimizar o desempenho em problemas específicos.</p>\n<p>Pré e Pós-processamento de Dados: Criar algoritmos para pré e pós-processamento de dados, incluindo filtragem e manipulação eficaz de dados de entrada e saída.</p>\n<p>Processamento de Dados Discretos, Imagens e Vídeos: Trabalhar com diferentes tipos de dados, incluindo dados discretos, imagens e vídeos, desenvolvendo soluções adaptadas a cada formato.</p>\n<p>Comparação entre Modelos Disponíveis: Avaliar e comparar modelos de inteligência artificial disponíveis, identificando as melhores abordagens para cada situação.</p>\n<p>Avaliação de Desempenho: Realizar avaliações rigorosas do desempenho dos algoritmos desenvolvidos, ajustando e refinando conforme necessário.</p>\n<p>Acompanhamento de Tendências Tecnológicas: Manter-se atualizado sobre as últimas tendências em inteligência artificial, machine learning e deep learning, garantindo que a empresa esteja utilizando as tecnologias mais recentes.</p>\n<p>Interpretação de Resultados: Além da avaliação de desempenho, interpretar resultados e fornecer insights significativos sobre o impacto e a eficácia dos modelos de IA implementados.</p>\n<p>Colaboração com Stakeholders: Trabalhar de perto com as partes interessadas, como líderes de negócios e usuários finais, para entender requisitos específicos e garantir que as soluções de IA atendam às necessidades do cliente.</p>\n<p>Documentação Abrangente: Reforçar a importância da documentação completa de todos os processos, desde a criação de datasets até a implementação de modelos, para garantir a rastreabilidade e compreensão por parte de outros membros da equipe.</p>\n<p>Treinamento e Desenvolvimento Interno: Contribuir para programas internos de treinamento em IA compartilhando conhecimentos e promovendo o desenvolvimento contínuo de habilidades dentro da equipe.</p>\n<p>Resolução de Problemas Emergentes: Desenvolver a capacidade de resolver problemas emergentes, como a adaptação a mudanças nos requisitos ou a implementação de soluções inovadoras para desafios específicos.</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Formação em Ciência da Computação, Engenharia de Computação, ou áreas relacionadas.</p>\n<p>Experiência de mais de 3 anos em pesquisa e desenvolvimento de algoritmos de inteligência artificial.</p>\n<p>Conhecimento profundo em criação de datasets, treinamento de redes neurais e avaliação de desempenho.</p>\n<p>Experiência em processamento de dados discretos, imagens e vídeos.</p>\n<p>Habilidade para conceber e implementar algoritmos eficazes para uma variedade de problemas.</p>\n<p>Familiaridade com frameworks de IA, como TensorFlow ou PyTorch.</p>\n<p>Excelentes habilidades analíticas e capacidade de solucionar problemas complexos.</p>\n<p>Boas habilidades de comunicação e colaboração em equipe.</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Remoto (Com visitas esporádicas no cliente)&nbsp;</li><li>Contratação PJ</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1748547,"hash":"L9694W84","position_name":"Analista de PCP","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\" _msttexthash=\"1135381\" _msthash=\"462\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p _msttexthash=\"1748799\" _msthash=\"351\">\n</p>\n<p _msttexthash=\"19712719\" _msthash=\"463\">Elaborar a programação de produção; <br _istranslated=\"1\"> Controlar níveis de estoque; <br _istranslated=\"1\"> Elaboração de relatórios e indicadores de produção; <br _istranslated=\"1\"> Acompanhamento de pedidos; <br _istranslated=\"1\"> Demais atividades pertinentes ao setor.</p>\n<p></p>\n<p _msttexthash=\"1042899\" _msthash=\"352\"><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n<font _mstmutation=\"1\" _msttexthash=\"653315\" _msthash=\"464\">Técnico ou superior na área;</font><br><font _mstmutation=\"1\" _msttexthash=\"793013\" _msthash=\"465\">Experiência no segmento do aço.</font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\" _msttexthash=\"260793\" _msthash=\"466\"><strong>O que oferecemos</strong></strong><br></p>\n<p _msttexthash=\"615355\" _msthash=\"354\"></p>\n<p _msttexthash=\"4632615\" _msthash=\"468\">Plano de saúde Unimed, vale-transporte, alimentação no local e seguro de vida coletivo.</p>\n<p _msttexthash=\"437749\" _msthash=\"467\"><strong>Horário:</strong><br>\nDas 8:00 às 18:00.</p>\n<p></p>\n<p><font _mstmutation=\"1\"></font><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1758022,"hash":"L86Y495V","position_name":"Analista de Produto - Arquiteto de Sistemas e Funções Veiculares","description":"<p>Indústria do setor automotivo contrata para System Design e Verificação de Requisitos.</p>\n<p><strong>Responsabilidades e Tarefas da Função</strong></p>\n<ul><li>Produzir e/ou alterar documentação técnica de funções veiculares ou revisar requisitos declarados com referência no INCOSE Systems Engineering Handbook;</li><li>Interpretar, criar, analisar funções de alto nível dentro da arquitetura de sistemas automotivos;</li><li>Se relacionar com especialistas, desenvolvedores e fornecedores da tecnologia ou função em questão;</li><li>Modelamento de requisitos (por exemplo usando SysML).</li></ul>\n<p><strong>Requisitos Obrigatórios</strong></p>\n<ul><li>Formação em engenharia Elétrica, Eletrônica, Mecatrônica, Computação ou Análise de Sistemas;</li><li>Ser apaixonado por carros e pela indústria automotiva;</li><li>Experiência em capturar e desenvolver requerimentos técnicos e/ou conteúdos funcionais;</li><li>Inglês Avançado;</li><li>Disponibilidade para residir em Belo Horizonte e região;</li></ul>\n<p><strong>Requisitos Complementares</strong></p>\n<ul><li>Experiência automotiva, escrita de requisitos e funções veiculares;</li><li>Curso técnico em eletrônica e gestão/escrita de requisitos para desenvolvimento de produtos HW/SW;</li><li>Arquitetura (System Design) de SW para Sistemas Embarcados;</li><li>Diferencial: Conhecimento de Doors, RTOS, AutoSAR, ISO Layers, DEVOPS, Qualidade de SW, Network (rede de dados automotivos ex.: CAN, CAN FD, LIN, CAN Hi Speed), Diagnósticos, ISO 26262 Segurança e Cyber Segurança;</li><li>Diferencial: Conhecimento amplo das funções veiculares de motor, transmissão, freio, direção, air bag, ADAS, infotainment, telematics e de conforto e conveniência (acessórios, vidros, porta, banco).</li></ul>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1785734,"hash":"L863X9W3","position_name":"Analista de Produto - Arquitetura (Network e Diagnose)","description":"<p>Indústria do setor automotivo contrata para Arquitetura de Sistemas (Diagnose).</p>\n<p><strong>Responsabilidades e Tarefas da Função</strong></p>\n<ul><li>Produzir e/ou alterar documentação técnica de funções veiculares ou revisar requisitos declarados com referência na Arquitetura, utilizando CANalyzer (para Network)&nbsp;e&nbsp;CANdelaStudio (para Diagnose), ambos da Vector;</li><li>Interpretar, criar, analisar funções de alto nível dentro da arquitetura de sistemas automotivos;</li><li>Se relacionar com especialistas, desenvolvedores e fornecedores da tecnologia ou função em questão;</li><li>Ler, analisar, identificar e definir módulos de falhas (DTCs).</li></ul>\n<p><strong>Requisitos Obrigatórios</strong></p>\n<ul><li>Formação em engenharia Elétrica, Eletrônica, Mecatrônica, Computação ou Análise de Sistemas;</li><li>Ser apaixonado por carros e pela indústria automotiva;</li><li>Experiência em capturar e desenvolver requerimentos técnicos e/ou conteúdos funcionais;</li><li>Inglês Avançado;</li><li>Disponibilidade para residir em Belo Horizonte e região;</li></ul>\n<p><strong>Requisitos Complementares</strong></p>\n<ul><li>Experiência automotiva, escrita de requisitos e funções veiculares;</li><li>Curso técnico em eletrônica e gestão/escrita de requisitos para desenvolvimento de produtos HW/SW;</li><li>Arquitetura (System Design) de SW para Sistemas Embarcados;</li><li>Diferencial: Conhecimento de Doors, RTOS, AutoSAR, ISO Layers, DEVOPS, Qualidade de SW, Network (rede de dados automotivos ex.: CAN, CAN FD, LIN, CAN Hi Speed e arquiteturas Atlantis e/ou SEA R2), Diagnósticos, ISO 26262 Segurança e Cyber Segurança;</li><li>Diferencial: Conhecimento amplo das funções veiculares de motor, transmissão, freio, direção, air bag, ADAS, infotainment, telematics e de conforto e conveniência (acessórios, vidros, porta, banco).</li></ul>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1746717,"hash":"L395RVXV","position_name":"Analista de Produto - PC/PR","description":"<p><br></p>\n<p>Estamos em busca de um profissional qualificado para integrar nossa equipe como Gestor de Projetos de Desenvolvimento de Produtos.</p>\n<p>Responsabilidades:</p>\n<ul><li>Liderar projetos de desenvolvimento de produtos, com ênfase em motores e sistemas: Refrigeração, alimentação de combustível, aspiração e exaustão.</li><li>Coordenar atividades desde a fase de sourcing até a implementação na produção seriada.</li><li>Desenvolver e executar planos de projeto, incluindo definição de atividades, alocação de recursos e cronogramas.</li><li>Garantir a aderência aos procedimentos da empresa e aos requisitos do Advanced Product Quality Planning (APQP).</li><li>Colaborar com equipes multifuncionais para identificar e resolver desafios técnicos e garantir o cumprimento dos objetivos do projeto.</li><li>Monitorar e relatar o progresso do projeto, identificando desvios e implementando ações corretivas quando necessário.</li><li>Comunicar-se efetivamente com todas as partes interessadas, incluindo equipes internas, fornecedores e clientes, garantindo a transparência e o alinhamento ao longo do ciclo de vida do projeto.</li></ul>\n<p>Requisitos:</p>\n<ul><li>Bacharelado em Engenharia Mecânica, Engenharia de Produção ou área relacionada.</li><li>Experiência comprovada em gestão de projetos de motores.</li><li>Familiaridade com os princípios do APQP e outras práticas de qualidade.</li><li>Excelentes habilidades de comunicação, liderança e resolução de problemas.</li><li>Capacidade comprovada de trabalhar efetivamente em equipes multifuncionais e de gerenciar múltiplos projetos simultaneamente.</li><li>Fluência em inglês.</li></ul>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1561293,"hash":"L77WW7W3","position_name":"Analista de Produto - Powertrain Calibração","description":"<p>Indústria do Setor Automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br>Desenvolvimento de calibração de controle motor para sistemas embarcados (Base, Emissões, Dirigibilidade e OBD). Definição do plano de testes, realização de testes e&nbsp;análise de dados. Preparação de documentação e relatórios técnicos.﻿﻿﻿</p>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br>Formação em Engenharia Mecânica, Elétrica, Mecatrônica ou Controle e Automação. Conhecimento em motores de combustão interna e sistemas de controle motor. Experiência em calibração de motores, testes em dinamômetro. Conhecimento Software INCA. Inglês avançado ou fluente.﻿﻿﻿</p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, auxílio alimentação, auxílio transporte</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933623,"hash":"L965RYY4","position_name":"Analista de Projetos","description":"<p>Junte-se a família PTC Group 🤩<br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙<br></p>\n<p>Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀<br></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Bill of Materials (BOM) responsável pela codificação das peças<br></p>\n<p>- Responsável pela codificação das peças de propulsion (que envolvem motorização e caixa de marcha principalmente, parte de resfriamento, câmbio de freio).</p>\n<p>- Receber a requisição da engenharia pela plataforma para criação ou modificação de uma peça de acordo com as necessidades de cada carro.</p>\n<p>- Utilizar o PLM para fazer as alterações e criações</p>\n<p>- Utilizar o Catia para posicionamento das peças na estrutura 3D.</p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">- Perfil analítico e focado</span><br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Inglês Avançado<br></p>\n<p><strong><strong>O que oferecemos</strong></strong><br></p>\n<p>CLT</p>\n<p>Trabalho hibrido Porto Real ou Betim</p>\n<p></p>","country":"Brazil","state":"State of Rio de Janeiro","city":"Porto Real","address":"","zipcode":"","location_display":"Porto Real, State of Rio de Janeiro, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1815828,"hash":"QY4R7XWV","position_name":"Analista de Projetos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\"></font></font></p><p>Empresa do ramo automotivo</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Bill of Materials (BOM) responsável pela codificação das peças<br></p>\n<p>- Responsável pela codificação das peças.</p>\n<p>- Receber a requisição da engenharia pela plataforma para criação ou modificação de uma peça de acordo com as necessidades de cada carro.</p>\n<p>- Utilizar o PLM para fazer as alterações e criações</p>\n<p>- Utilizar o Catia para posicionamento das peças na estrutura 3D.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Inglês Avançado</p>\n<p><strong><strong>O que oferecemos</strong></strong><br></p>\n<p>CLT</p>\n<p>Trabalho hibrido em Porto Real ou Betim</p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\"></font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"RJ","city":"Porto Real","address":"","zipcode":"","location_display":"Porto Real, RJ, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1848419,"hash":"L538W4Y5","position_name":"Analista de Projetos - Suspensão","description":"<p>Profissional será responsável por acompanhar e validar projetos de suspensão.</p>\n<p>REQUISITOS OBRIGATÓRIOS<br></p>\n<p>Inglês avançado</p>\n<p>Curso superior completo em engenharia mecânica ou áreas afins</p>\n<p>REQUISITOS DESEJÁVEIS</p>\n<p>Desejável conhecimento em PLM, CATIA, NX e TeamCenter</p>\n<p>Desejável conhecimento em projetos de suspensão</p>\n<p>MODALIDADE:</p>\n<p>CLT<br>Hibrido em Betim - MG</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:51 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=3","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/","results":[{"id":1729118,"hash":"L4736YWV","position_name":"Analista de Engenharia de Custos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">RESPONSABILIDADES DO CARGO/ ATIVIDADES A DESENVOLVER:</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Suporte para o monitoramento de Custo Total do Produto (TPC) e Ferramental do Fornecedor&nbsp;de veículos em desenvolvimento</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Execução de planilhas de monitoramento</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Garantia da precisão e alinhamento dos números que compõe o TPC e VT, interagindo com as áreas envolvidas.</font></font><br>﻿<br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿DESAFIOS DA POSIÇÃO:</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Compreensão dos inputs de trabalho (escopo técnico / prazos / perímetrtos)</font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿Integração com as áreas envolvidas no TPC para sincronismo e robustez das informações Gestão do tempo.</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">CONHECIMENTOS TÉCNICO / IDIOMAS / INFORMÁTICA:</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Gerenciamento de projeto: médio</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento de processos de desenvolvimento de produtos automotivos: médio</font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿Conhecimento em custos ou finanças: alto</font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿﻿Inglês: avançado </font></font><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">﻿Microsoft office: avançado</font></font></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716644,"hash":"L689Y635","position_name":"Analista de IA - PL","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Analista de Inteligência Artificial (IA) Pleno desempenha um papel central na equipe de pesquisa, sendo responsável por pesquisar, desenvolver e implementar soluções inovadoras de algoritmos para problemas complexos utilizando técnicas de inteligência artificial. Este profissional possui experiência sólida em criação de datasets, treinamento de redes neurais, concepção de algoritmos, avaliação de desempenho, com foco tanto em dados discretos quanto em imagens e vídeos.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Pesquisa e Desenvolvimento de Algoritmos: Conduzir pesquisa constante para identificar e implementar algoritmos avançados de inteligência artificial para resolver problemas específicos.</p>\n<p>Criação de Datasets: Desenvolver e criar datasets anotados para treinamento e validação de redes neurais, garantindo a representação adequada dos dados.</p>\n<p>Composição de Algoritmos: Desenvolver algoritmos e modelos de IA combinando diferentes técnicas para otimizar o desempenho em problemas específicos.</p>\n<p>Pré e Pós-processamento de Dados: Criar algoritmos para pré e pós-processamento de dados, incluindo filtragem e manipulação eficaz de dados de entrada e saída.</p>\n<p>Processamento de Dados Discretos, Imagens e Vídeos: Trabalhar com diferentes tipos de dados, incluindo dados discretos, imagens e vídeos, desenvolvendo soluções adaptadas a cada formato.</p>\n<p>Comparação entre Modelos Disponíveis: Avaliar e comparar modelos de inteligência artificial disponíveis, identificando as melhores abordagens para cada situação.</p>\n<p>Avaliação de Desempenho: Realizar avaliações rigorosas do desempenho dos algoritmos desenvolvidos, ajustando e refinando conforme necessário.</p>\n<p>Acompanhamento de Tendências Tecnológicas: Manter-se atualizado sobre as últimas tendências em inteligência artificial, machine learning e deep learning, garantindo que a empresa esteja utilizando as tecnologias mais recentes.</p>\n<p>Interpretação de Resultados: Além da avaliação de desempenho, interpretar resultados e fornecer insights significativos sobre o impacto e a eficácia dos modelos de IA implementados.</p>\n<p>Colaboração com Stakeholders: Trabalhar de perto com as partes interessadas, como líderes de negócios e usuários finais, para entender requisitos específicos e garantir que as soluções de IA atendam às necessidades do cliente.</p>\n<p>Documentação Abrangente: Reforçar a importância da documentação completa de todos os processos, desde a criação de datasets até a implementação de modelos, para garantir a rastreabilidade e compreensão por parte de outros membros da equipe.</p>\n<p>Treinamento e Desenvolvimento Interno: Contribuir para programas internos de treinamento em IA compartilhando conhecimentos e promovendo o desenvolvimento contínuo de habilidades dentro da equipe.</p>\n<p>Resolução de Problemas Emergentes: Desenvolver a capacidade de resolver problemas emergentes, como a adaptação a mudanças nos requisitos ou a implementação de soluções inovadoras para desafios específicos.</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Formação em Ciência da Computação, Engenharia de Computação, ou áreas relacionadas.</p>\n<p>Experiência de mais de 3 anos em pesquisa e desenvolvimento de algoritmos de inteligência artificial.</p>\n<p>Conhecimento profundo em criação de datasets, treinamento de redes neurais e avaliação de desempenho.</p>\n<p>Experiência em processamento de dados discretos, imagens e vídeos.</p>\n<p>Habilidade para conceber e implementar algoritmos eficazes para uma variedade de problemas.</p>\n<p>Familiaridade com frameworks de IA, como TensorFlow ou PyTorch.</p>\n<p>Excelentes habilidades analíticas e capacidade de solucionar problemas complexos.</p>\n<p>Boas habilidades de comunicação e colaboração em equipe.</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Remoto (Com visitas esporádicas no cliente)&nbsp;</li><li>Contratação PJ</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1748547,"hash":"L9694W84","position_name":"Analista de PCP","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\" _msttexthash=\"1135381\" _msthash=\"462\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p _msttexthash=\"1748799\" _msthash=\"351\">\n</p>\n<p _msttexthash=\"19712719\" _msthash=\"463\">Elaborar a programação de produção; <br _istranslated=\"1\"> Controlar níveis de estoque; <br _istranslated=\"1\"> Elaboração de relatórios e indicadores de produção; <br _istranslated=\"1\"> Acompanhamento de pedidos; <br _istranslated=\"1\"> Demais atividades pertinentes ao setor.</p>\n<p></p>\n<p _msttexthash=\"1042899\" _msthash=\"352\"><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n<font _mstmutation=\"1\" _msttexthash=\"653315\" _msthash=\"464\">Técnico ou superior na área;</font><br><font _mstmutation=\"1\" _msttexthash=\"793013\" _msthash=\"465\">Experiência no segmento do aço.</font></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\" _msttexthash=\"260793\" _msthash=\"466\"><strong>O que oferecemos</strong></strong><br></p>\n<p _msttexthash=\"615355\" _msthash=\"354\"></p>\n<p _msttexthash=\"4632615\" _msthash=\"468\">Plano de saúde Unimed, vale-transporte, alimentação no local e seguro de vida coletivo.</p>\n<p _msttexthash=\"437749\" _msthash=\"467\"><strong>Horário:</strong><br>\nDas 8:00 às 18:00.</p>\n<p></p>\n<p><font _mstmutation=\"1\"></font><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1758022,"hash":"L86Y495V","position_name":"Analista de Produto - Arquiteto de Sistemas e Funções Veiculares","description":"<p>Indústria do setor automotivo contrata para System Design e Verificação de Requisitos.</p>\n<p><strong>Responsabilidades e Tarefas da Função</strong></p>\n<ul><li>Produzir e/ou alterar documentação técnica de funções veiculares ou revisar requisitos declarados com referência no INCOSE Systems Engineering Handbook;</li><li>Interpretar, criar, analisar funções de alto nível dentro da arquitetura de sistemas automotivos;</li><li>Se relacionar com especialistas, desenvolvedores e fornecedores da tecnologia ou função em questão;</li><li>Modelamento de requisitos (por exemplo usando SysML).</li></ul>\n<p><strong>Requisitos Obrigatórios</strong></p>\n<ul><li>Formação em engenharia Elétrica, Eletrônica, Mecatrônica, Computação ou Análise de Sistemas;</li><li>Ser apaixonado por carros e pela indústria automotiva;</li><li>Experiência em capturar e desenvolver requerimentos técnicos e/ou conteúdos funcionais;</li><li>Inglês Avançado;</li><li>Disponibilidade para residir em Belo Horizonte e região;</li></ul>\n<p><strong>Requisitos Complementares</strong></p>\n<ul><li>Experiência automotiva, escrita de requisitos e funções veiculares;</li><li>Curso técnico em eletrônica e gestão/escrita de requisitos para desenvolvimento de produtos HW/SW;</li><li>Arquitetura (System Design) de SW para Sistemas Embarcados;</li><li>Diferencial: Conhecimento de Doors, RTOS, AutoSAR, ISO Layers, DEVOPS, Qualidade de SW, Network (rede de dados automotivos ex.: CAN, CAN FD, LIN, CAN Hi Speed), Diagnósticos, ISO 26262 Segurança e Cyber Segurança;</li><li>Diferencial: Conhecimento amplo das funções veiculares de motor, transmissão, freio, direção, air bag, ADAS, infotainment, telematics e de conforto e conveniência (acessórios, vidros, porta, banco).</li></ul>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1785734,"hash":"L863X9W3","position_name":"Analista de Produto - Arquitetura (Network e Diagnose)","description":"<p>Indústria do setor automotivo contrata para Arquitetura de Sistemas (Diagnose).</p>\n<p><strong>Responsabilidades e Tarefas da Função</strong></p>\n<ul><li>Produzir e/ou alterar documentação técnica de funções veiculares ou revisar requisitos declarados com referência na Arquitetura, utilizando CANalyzer (para Network)&nbsp;e&nbsp;CANdelaStudio (para Diagnose), ambos da Vector;</li><li>Interpretar, criar, analisar funções de alto nível dentro da arquitetura de sistemas automotivos;</li><li>Se relacionar com especialistas, desenvolvedores e fornecedores da tecnologia ou função em questão;</li><li>Ler, analisar, identificar e definir módulos de falhas (DTCs).</li></ul>\n<p><strong>Requisitos Obrigatórios</strong></p>\n<ul><li>Formação em engenharia Elétrica, Eletrônica, Mecatrônica, Computação ou Análise de Sistemas;</li><li>Ser apaixonado por carros e pela indústria automotiva;</li><li>Experiência em capturar e desenvolver requerimentos técnicos e/ou conteúdos funcionais;</li><li>Inglês Avançado;</li><li>Disponibilidade para residir em Belo Horizonte e região;</li></ul>\n<p><strong>Requisitos Complementares</strong></p>\n<ul><li>Experiência automotiva, escrita de requisitos e funções veiculares;</li><li>Curso técnico em eletrônica e gestão/escrita de requisitos para desenvolvimento de produtos HW/SW;</li><li>Arquitetura (System Design) de SW para Sistemas Embarcados;</li><li>Diferencial: Conhecimento de Doors, RTOS, AutoSAR, ISO Layers, DEVOPS, Qualidade de SW, Network (rede de dados automotivos ex.: CAN, CAN FD, LIN, CAN Hi Speed e arquiteturas Atlantis e/ou SEA R2), Diagnósticos, ISO 26262 Segurança e Cyber Segurança;</li><li>Diferencial: Conhecimento amplo das funções veiculares de motor, transmissão, freio, direção, air bag, ADAS, infotainment, telematics e de conforto e conveniência (acessórios, vidros, porta, banco).</li></ul>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1746717,"hash":"L395RVXV","position_name":"Analista de Produto - PC/PR","description":"<p><br></p>\n<p>Estamos em busca de um profissional qualificado para integrar nossa equipe como Gestor de Projetos de Desenvolvimento de Produtos.</p>\n<p>Responsabilidades:</p>\n<ul><li>Liderar projetos de desenvolvimento de produtos, com ênfase em motores e sistemas: Refrigeração, alimentação de combustível, aspiração e exaustão.</li><li>Coordenar atividades desde a fase de sourcing até a implementação na produção seriada.</li><li>Desenvolver e executar planos de projeto, incluindo definição de atividades, alocação de recursos e cronogramas.</li><li>Garantir a aderência aos procedimentos da empresa e aos requisitos do Advanced Product Quality Planning (APQP).</li><li>Colaborar com equipes multifuncionais para identificar e resolver desafios técnicos e garantir o cumprimento dos objetivos do projeto.</li><li>Monitorar e relatar o progresso do projeto, identificando desvios e implementando ações corretivas quando necessário.</li><li>Comunicar-se efetivamente com todas as partes interessadas, incluindo equipes internas, fornecedores e clientes, garantindo a transparência e o alinhamento ao longo do ciclo de vida do projeto.</li></ul>\n<p>Requisitos:</p>\n<ul><li>Bacharelado em Engenharia Mecânica, Engenharia de Produção ou área relacionada.</li><li>Experiência comprovada em gestão de projetos de motores.</li><li>Familiaridade com os princípios do APQP e outras práticas de qualidade.</li><li>Excelentes habilidades de comunicação, liderança e resolução de problemas.</li><li>Capacidade comprovada de trabalhar efetivamente em equipes multifuncionais e de gerenciar múltiplos projetos simultaneamente.</li><li>Fluência em inglês.</li></ul>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1561293,"hash":"L77WW7W3","position_name":"Analista de Produto - Powertrain Calibração","description":"<p>Indústria do Setor Automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br>Desenvolvimento de calibração de controle motor para sistemas embarcados (Base, Emissões, Dirigibilidade e OBD). Definição do plano de testes, realização de testes e&nbsp;análise de dados. Preparação de documentação e relatórios técnicos.﻿﻿﻿</p>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br>Formação em Engenharia Mecânica, Elétrica, Mecatrônica ou Controle e Automação. Conhecimento em motores de combustão interna e sistemas de controle motor. Experiência em calibração de motores, testes em dinamômetro. Conhecimento Software INCA. Inglês avançado ou fluente.﻿﻿﻿</p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, auxílio alimentação, auxílio transporte</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933623,"hash":"L965RYY4","position_name":"Analista de Projetos","description":"<p>Junte-se a família PTC Group 🤩<br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙<br></p>\n<p>Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀<br></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Bill of Materials (BOM) responsável pela codificação das peças<br></p>\n<p>- Responsável pela codificação das peças de propulsion (que envolvem motorização e caixa de marcha principalmente, parte de resfriamento, câmbio de freio).</p>\n<p>- Receber a requisição da engenharia pela plataforma para criação ou modificação de uma peça de acordo com as necessidades de cada carro.</p>\n<p>- Utilizar o PLM para fazer as alterações e criações</p>\n<p>- Utilizar o Catia para posicionamento das peças na estrutura 3D.</p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">- Perfil analítico e focado</span><br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Inglês Avançado<br></p>\n<p><strong><strong>O que oferecemos</strong></strong><br></p>\n<p>CLT</p>\n<p>Trabalho hibrido Porto Real ou Betim</p>\n<p></p>","country":"Brazil","state":"State of Rio de Janeiro","city":"Porto Real","address":"","zipcode":"","location_display":"Porto Real, State of Rio de Janeiro, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1815828,"hash":"QY4R7XWV","position_name":"Analista de Projetos","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\"></font></font></p><p>Empresa do ramo automotivo</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Bill of Materials (BOM) responsável pela codificação das peças<br></p>\n<p>- Responsável pela codificação das peças.</p>\n<p>- Receber a requisição da engenharia pela plataforma para criação ou modificação de uma peça de acordo com as necessidades de cada carro.</p>\n<p>- Utilizar o PLM para fazer as alterações e criações</p>\n<p>- Utilizar o Catia para posicionamento das peças na estrutura 3D.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Inglês Avançado</p>\n<p><strong><strong>O que oferecemos</strong></strong><br></p>\n<p>CLT</p>\n<p>Trabalho hibrido em Porto Real ou Betim</p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\"></font></font></p>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"RJ","city":"Porto Real","address":"","zipcode":"","location_display":"Porto Real, RJ, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1848419,"hash":"L538W4Y5","position_name":"Analista de Projetos - Suspensão","description":"<p>Profissional será responsável por acompanhar e validar projetos de suspensão.</p>\n<p>REQUISITOS OBRIGATÓRIOS<br></p>\n<p>Inglês avançado</p>\n<p>Curso superior completo em engenharia mecânica ou áreas afins</p>\n<p>REQUISITOS DESEJÁVEIS</p>\n<p>Desejável conhecimento em PLM, CATIA, NX e TeamCenter</p>\n<p>Desejável conhecimento em projetos de suspensão</p>\n<p>MODALIDADE:</p>\n<p>CLT<br>Hibrido em Betim - MG</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:35 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=3
@@ -304,7 +304,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:52 GMT
+      - Tue, 30 Jul 2024 16:28:36 GMT
       Content-Type:
       - application/json
       Content-Length:
@@ -329,8 +329,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=4","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","results":[{"id":1718186,"hash":"QW9WW5W6","position_name":"Analista de QA","description":"<p><strong>Responsabilidades e atribuições:</strong></p>\n<p>-&nbsp;Experiência na análise de teste, incluindo análise de risco e design de testes --&nbsp;Experiência na estratégia de teste, trabalhando em conjunto com os DEVs da equipe no apontamento de quais testes utilizar, como testes funcionais de baixo nível, testes de contrato de serviço e testes de UI.</p>\n<p>- Experiência em testes exploratórios, portando-se como o usuário final do produto, realizando testes de coisas que ainda não estavam descritas como requisitos para serem analisados.</p>\n<p>- Analisar todos os aspectos de utilização do software ou aplicação</p>\n<p>- Verificar se tudo está sendo entregue conforme a expectativa do cliente</p>\n<p>- Orquestrar o trabalho de todos para que tudo saia conforme o esperado, reportando possíveis problemas e buscando melhorias constantes</p>\n<p>- Atuação em projetos de desenvolvimento ágil&nbsp;</p>\n<p><strong>Habilidades:</strong></p>\n<p>- Visão Sistêmica do QA</p>\n<p>- Planejamento e Acompanhamento- Atenção e Foco nas atividades do QA</p>\n<p>- Trabalho em Equipe e Relacionamento Interpessoal</p>\n<p>- Comunicação- Negociação</p>\n<p>- Proatividade</p>\n<p>- Resiliência</p>\n<p>- Gestão de Risco</p>\n<p>Deve ser um profissional sênior com experiência em implantar a área de QA, pois hoje os testes são realizados pelos desenvolvedores, líder técnico e o product owner.</p>\n<p>Não temos ferramenta implantada.</p><p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Informações Adicionais</strong><span style=\"font-family: inherit; font-size: 0.875rem;\">:</span><br></p>\n<ul><li>Presencial: Remoto (Com visitas esporádicas no cliente) </li><li>Contratação PJ</li></ul>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1836259,"hash":"L96XV656","position_name":"Analista de Segurança da Informação Jr","description":"<p>Com mais de 190 lojas no Brasil e na Colômbia, o Grupo desponta no agronegócio como a maior distribuidora de insumos agrícolas da América Latina. Criado a partir da fusão e aquisição de mais de 20 distribuidoras de grande e médio porte, sob o controle do Fundo Pátria Investimentos, o grupo possui marcas próprias de agroquímicos, fertilizantes foliares e biológicos.<br></p>\n<h4>Responsabilidades e Tarefas:</h4>\n<ul><li>Acompanhar as ocorrências de vulnerabilidades e incidentes cibernéticos apontadas pelo SOC.</li><li>Endereçar à infraestrutura de TI as correções das vulnerabilidades levantadas pelo SOC.</li><li>Propor a mitigação dos incidentes cibernéticos encontrados pelo SOC, principalmente os críticos e severos, e colaborar com a infraestrutura de TI para soluções conjuntas.</li></ul>\n<h4>Atividades:</h4>\n<ul><li>Acompanhar as solicitações feitas pelo SOC para mitigar incidentes de cibersegurança.</li><li>Receber as vulnerabilidades apontadas pelo SOC e endereçá-las à infraestrutura de TI para solução via abertura de chamados.</li><li>Homologar ferramentas e fornecedores em projetos relacionados à segurança da informação.</li><li>Realizar assessment de segurança e análise de vulnerabilidades na infraestrutura on-premises e cloud, bem como de aplicações.</li><li>Prestar suporte técnico de nível 3 (troubleshooting) em eventos críticos de segurança.</li></ul>\n<h4>Requisitos Obrigatórios:</h4>\n<ul><li>Forte conhecimento em segurança cibernética e sistemas operacionais Windows e Linux.</li><li>Vivência com times de segurança ofensiva e defensiva.</li><li>Experiência em comunicação e documentação de ameaças identificadas, utilizando métodos e técnicas de exploração.</li><li>Conhecimentos em soluções de segurança como DLP, Firewall, WAF, IPS/IDS, Gestão de Identidade e Acesso (IAM), SIEM, Antivírus, Criptografia e verificação de vulnerabilidades.</li><li>Conhecimentos de arquitetura de redes (TCP/IP, LAN, WAN, VLAN, links e protocolos de comunicação).</li><li>Bons conhecimentos na elaboração e uso de scripts Shell e PowerShell.</li><li>Excelentes conhecimentos de AD 365 ENTRA.</li><li>Ensino Superior em Segurança da Informação ou cursos relacionados.</li></ul>\n<h4>Experiência:</h4>\n<ul><li>Mínimo de 2 anos em redes TCP/IP.</li><li>Conhecimento dos frameworks NIST e MITRE ATT&amp;CK.</li></ul>\n<h4>Conhecimentos Adicionais Desejáveis:</h4>\n<ul><li>Conhecimento da ISO 27001.</li><li>Conhecimento de regramento de firewalls.</li><li>Conhecimento de antivírus EDR/XDR.</li><li>Conhecimento de ferramentas de monitoramento de redes.</li><li>Inglês básico.</li></ul>\n<h4>Informações Complementares:</h4>\n<ul><li>Profissional proativo, capaz de encontrar soluções para eventuais dificuldades e melhorias nos ativos de segurança da informação.</li><li>Capacidade de trabalho em equipe.</li></ul>\n<p><strong>Local de Trabalho:</strong>&nbsp;Híbrido:&nbsp;3 presencial em Curitiba&nbsp;<br><strong>Horário:</strong> Das 08h às 12h e das 13h às 17h48 (plantão/noites e possíveis horas extras)<br><strong>Tipo de Contratação:</strong> CLT ou PJ</p>\n<h4><br>\n\n</h4>","country":"Brazil","state":"PR","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, PR, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1801585,"hash":"QVX3VXW6","position_name":"Analista de Suporte","description":"<p><span dir=\"ltr\" data-redactor-span=\"true\"></span></p><p><strong>Analista de Suporte de TI</strong><br><br><strong>Requisitos e qualificações</strong></p>\n<ul><li>Fornecer suporte técnico presencial a funcionários, solucionando problemas de hardware, software e conectividade de rede de maneira eficaz e amigável.</li><li>Diagnosticar e resolver problemas de TI, incluindo problemas relacionados a sistemas operacionais (Windows, MacOS), redes, hardware de computador e periféricos.</li><li>Desenvolver soluções de automação usando ferramentas do Microsoft Office, como Excel e Power Automate, para otimizar tarefas e melhorar a eficiência operacional.</li><li>Manter registros precisos de tickets de suporte, garantindo que todas as solicitações sejam rastreadas e resolvidas de maneira oportuna.</li><li>Realizar manutenção preventiva em computadores e periféricos, garantindo a estabilidade e a confiabilidade do ambiente de trabalho.</li><li>Treinar os usuários finais sobre melhores práticas de segurança cibernética e uso eficaz da tecnologia.</li><li>Realizar checklist diários aos sistemas de videoconferência instalados nas salas de reunião. Recepcionar e entregar equipamentos para novos colaboradores que estejam entrando na companhia.</li><li>Acionar e acompanhar fornecedores em caso de necessidade Controlar estoque da TI local composto por computadores e celulares.</li><li>Qualificações: Experiência comprovada em suporte técnico presencial e solução de problemas de TI.</li><li>Conhecimento sólido em sistemas operacionais Windows e MacOS.</li><li>Excelentes habilidades de comunicação e capacidade de explicar questões técnicas de forma simples para usuários de diferentes níveis de habilidade.</li><li>Formação em Tecnologia da Informação ou campo relacionado é preferível.</li><li>Forte ética de trabalho, pró-atividade e capacidade de trabalhar tanto de forma independente quanto em equipe</li></ul>\n<p></p>\n<p><strong>Desejáveis</strong></p>\n<ul><li>Colaborar com outros membros da equipe de TI para garantir a integração perfeita de sistemas e a implementação de soluções tecnológicas eficazes.</li><li>Habilidade demonstrada em automatização de tarefas com o Microsoft Office, incluindo Excel e Power Automate.</li><li>Certificações relevantes em suporte técnico de computadores e Microsoft Office.</li><li>Modelo de trabalho: Presencial (Vila Olimpia- SP)</li><li>Tipo de contrato: CLT</li></ul>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1714494,"hash":"L8RV833R","position_name":"Analista de Suporte de TI","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p></p><li>Planejar e executar projetos de TI voltados à infraestrutura.</li><li>Diariamente monitorar o funcionamento de hardwares , links e instalações de TI locais e remotas.</li><li>Realizar atividades de suporte da operação, manutenção preventiva, corretiva e de melhoria contínua nos ativos de TI (ex.: servidores, switches, roteadores, access points, periféricos, e sistemas de automação);</li><li>Visar o pleno funcionamento do parque tecnológico além de atender às exigências das normas do sistema de qualidade e LGPD da empresa.</li><p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></strong></p><p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Obrigatórios</strong></strong><br></p><p>Este profissional deverá ter habilidade em relacionamento com a área de Tecnologia da Informação, capacidade de comunicação com diversos tipos de pessoas e áreas, para contribuir e fazer parcerias com todas as verticais da organização. Possuir visão global sobre funcionalidades e problemas, atuando de forma analítica, raciocínio lógico, pró-atividade, organização e disciplina.<br></p>\n<ul><li>Conhecimento da física e lógica de redes TCP/IP, ranges de IP, subnets/máscaras, gateways, roteamento, topologia de rede e rede óptica.</li><li>Desenvolvimento e acompanhamento de projetos e suas fases (produtos e serviços) em andamento.</li><li>Atendimento aos clientes internos e externos através de dúvidas e necessidades, elaboração de documentação técnica, análise e solução de problemas, atendimento de chamados, atendimento de pedidos via ferramenta de suporte corporativo.</li><li>Conhecimento sistemas operacionais (Windows, Linux);</li><li>Conhecimento em Pacote Office(Word, Excel, PowerPoint), e Office 365.</li><li>Mantém-se informado sobre novas tendências, técnicas, materiais, equipamentos e procedimentos que possam impactar sua atividade;</li><li>Conhecimento em Cloud Azure</li><li>Disponibilidade para viagens entre as unidades.</li></ul>\n<p><strong><strong>﻿Informações Adicionais:&nbsp;&nbsp;<br>﻿</strong></strong>Contratação:&nbsp;CLT<strong><strong>&nbsp;&nbsp;</strong></strong><br>Modelo de trabalho: Presencial em Lorena/SP&nbsp;</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"Lorena","address":"","zipcode":"","location_display":"Lorena, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1789060,"hash":"LR4V7R6R","position_name":"Analista de Suporte N2","description":"<p>Com mais de 190 lojas no Brasil e na Colômbia, o Grupo desponta no Agronegócio como a maior distribuidora de insumos agrícolas da América Latina, foi criada a partir da fusão e aquisição de mais de 20 distribuidoras de grande e médio porte, sob o controle do Fundo Pátria Investimentos. Além disso, o grupo possui marcas próprias de agroquímicos, fertilizantes foliares e biológicos.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong></p>\n<p>Gerenciar a abertura de chamados, gerenciar acessos de usuários, fazer o acompanhamento e monitoramento destes usuários, realizar instalações e configurações de hardware e software e dar suporte técnico aos colaboradores Lavoro.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong></p>\n<ul><li>Experiência em suporte a microinformática;</li><li>Experiência em Windows;</li><li>Experiência, impressoras;</li><li>Experiência em rede.</li></ul>\n<p><strong>Requisitos Complementares﻿</strong></p>\n<ul><li>Ter perfil hands-on.</li></ul><p><strong>Informações Adicionais</strong>:</p>\n<ul><ul><li>Presencial em Curitiba/PR</li><li>Contratação CLT</li></ul></ul>","country":"Brazil","state":"PR","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, PR, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933555,"hash":"L53XY583","position_name":"Analista de Suporte Pleno","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Fornecer suporte aos usuários e ao parque de computadores da empresa, com<br>objetivo de garantir a disponibilidade, estabilidade e atualização constante do<br>ambiente de TI. Acompanhar e executar processos e procedimentos de segurança<br>na rede.<br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>Experiência sólida com operações de TI<br>Suporte a usuários, instalação e configuração de computadores, redes<br>estruturadas, WIFI e roteadores.<br>Conhecimento em ferramentas de backup, virtualização; switches gerenciáveis,<br>Vlan, WIFI e roteadores.<br>Ter disponibilidade de viagens para atender outras unidades.</p>\n<p><strong><strong>O que oferecemos</strong></strong></p><p><strong><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Alimentação no local, seguro de vida, plano de saúde e convênio de farmácia.</span></p>\n<p></p>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716609,"hash":"L7793V93","position_name":"Analista de Testes - JR","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Analista de Testes Júnior desempenha um papel fundamental na equipe de garantia de qualidade, contribuindo para a identificação e resolução de defeitos nos produtos de software. Com um foco em aprendizado contínuo, este profissional apoia a execução de testes, a documentação de resultados e a colaboração com equipes multidisciplinares para assegurar a entrega de software de alta qualidade.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Execução de Testes: Participar ativamente da execução de testes manuais e/ou automatizados, seguindo os casos de teste estabelecidos.</p>\n<p>Documentação de Resultados: Registrar de maneira clara e precisa os resultados dos testes, identificando e documentando defeitos conforme necessário.</p>\n<p>Colaboração com a Equipe: Colaborar com os membros da equipe de desenvolvimento e analistas de teste mais experientes para entender o contexto do software e contribuir para o processo de resolução de defeitos.</p>\n<p>Aprendizado Contínuo: Participar de treinamentos e desenvolvimento profissional para aprimorar as habilidades em testes de software e se manter atualizado com as melhores práticas da indústria.</p>\n<p>Melhoria de Processos: Contribuir para a melhoria contínua dos processos de teste, sugerindo ideias e abordagens inovadoras.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Ciência da Computação, Engenharia de Software, ou áreas relacionadas.</p>\n<p>Familiaridade com conceitos básicos de testes de software.</p>\n<p>Desejo de aprender e crescer na área de garantia de qualidade.</p>\n<p>Habilidade para trabalhar de forma colaborativa em ambientes ágeis.</p>\n<p>Boa capacidade de comunicação verbal e escrita.</p>\n<p>Entre 1 e 2 anos de experiência com testes de software</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Presencial&nbsp;em São José dos Campos/SP&nbsp;</li><li>Contratação PJ</li></ul>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1604349,"hash":"QV7848YR","position_name":"Analista de Vendas","description":"<p><strong><strong _msttexthash=\"1135381\" _msthash=\"6856\">Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><strong _msttexthash=\"240318\" _msthash=\"6857\">DESCRIÇÃO DA VAGA</strong><br></p>\n<p _msttexthash=\"87372233\" _msthash=\"6858\">Estamos à procura de um profissional dinâmico e comprometido para a posição de Executivo(a) de Vendas de Aço, que possua experiência com vendas de Aço Carbono. Se você é apaixonado por vendas, tem habilidades de negociação e busca crescimento profissional e deseja fazer parte de uma empresa líder na distribuição de aço e centro de serviços de aço no Brasil, esta pode ser a oportunidade perfeita para você!</p>\n<h2><strong _msttexthash=\"699088\" _msthash=\"6859\">RESPONSABILIDADES E ATRIBUIÇÕES</strong></h2>\n<p _msttexthash=\"364078\" _msthash=\"6860\">Responsabilidades:</p>\n<p></p>\n<ul><li _msttexthash=\"465452\" _msthash=\"6861\">Atendimento ao Cliente:</li><li _msttexthash=\"15889796\" _msthash=\"6862\">Atender clientes, identificando suas necessidades e orientando-os com todas as informações necessárias sobre os produtos disponíveis e sua adequada utilização.</li><li _msttexthash=\"4582344\" _msthash=\"6863\">Analisar sugestões dos clientes sobre o atendimento recebido e os produtos oferecidos.</li><li _msttexthash=\"420875\" _msthash=\"6864\">Estratégia de vendas:</li><li _msttexthash=\"8518445\" _msthash=\"6865\">Observar as práticas da concorrência quanto a preços, ofertas, etc., apresentando sugestões para incrementar as vendas.</li><li _msttexthash=\"8204170\" _msthash=\"6866\">Manter-se bem informado quanto às condições de vendas da empresa e como se comparam com as condições da concorrência.</li><li _msttexthash=\"714896\" _msthash=\"6867\">Negociação e Relacionamento:</li><li _msttexthash=\"9787245\" _msthash=\"6868\">Negociar preços e prazos com clientes, através de propostas escritas e/ou telefone, dentro dos limites estabelecidos pela empresa.</li><li _msttexthash=\"4986618\" _msthash=\"6869\">Anotar as consultas de clientes relacionadas com mercadorias não disponíveis em estoque.</li><li _msttexthash=\"721929\" _msthash=\"6870\">Organização e Comunicação:</li><li _msttexthash=\"13657280\" _msthash=\"6871\">Manter seu local de trabalho e áreas em volta, equipamentos organizados e limpos, além de zelar pela conservação e manutenção dos locais de utilização.</li><li _msttexthash=\"4075305\" _msthash=\"6872\">Elaborar e repassar relatórios sob sua responsabilidade nos prazos estipulados.</li></ul>\n<h2><strong _msttexthash=\"525785\" _msthash=\"6873\">REQUISITOS E QUALIFICAÇÕES</strong></h2>\n<p _msttexthash=\"176592\" _msthash=\"6874\">Requisitos:</p>\n<ul><li _msttexthash=\"462969\" _msthash=\"6875\">Ensino médio completo.</li><li _msttexthash=\"1709045\" _msthash=\"6876\">Experiência com vendas no segmento de aço carbono.</li><li _msttexthash=\"717743\" _msthash=\"6877\">Possuir veículo próprio e CNH.</li><li _msttexthash=\"711113\" _msthash=\"6878\">Disponibilidade para viagens.</li><li _msttexthash=\"537745\" _msthash=\"6879\">Paixão por superar metas.</li><li _msttexthash=\"1621009\" _msthash=\"6880\">Boa fluência verbal e habilidade em negociação.</li><li _msttexthash=\"1517230\" _msthash=\"6881\">Postura profissional e senso de organização.</li></ul>\n<p></p>\n<p></p>","country":"Brazil","state":"PR","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, PR, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1604077,"hash":"L378368W","position_name":"Analista de Vendas","description":"<p><strong>DESCRIÇÃO DA VAGA</strong></p>\n<p>Estamos à procura de um profissional dinâmico e comprometido para a posição de Analista de Vendas de Aço. Se você é apaixonado por vendas, tem habilidades de negociação e busca crescimento profissional e deseja fazer parte de uma empresa líder na distribuição de aço e centro de serviços de aço no Brasil, esta pode ser a oportunidade perfeita para você!</p>\n<h2><strong>RESPONSABILIDADES E ATRIBUIÇÕES</strong></h2>\n<ul><li>Atendimento ao Cliente:</li><li>Atender clientes, identificando suas necessidades e orientando-os com todas as informações necessárias sobre os produtos disponíveis e sua adequada utilização.</li><li>Analisar sugestões dos clientes sobre o atendimento recebido e os produtos oferecidos.</li><li>Estratégia de vendas:</li><li>Observar as práticas da concorrência quanto a preços, ofertas, etc., apresentando sugestões para incrementar as vendas.</li><li>Manter-se bem informado quanto às condições de vendas da empresa e como se comparam com as condições da concorrência.</li><li>Negociação e Relacionamento:</li><li>Negociar preços e prazos com clientes, através de propostas escritas e/ou telefone, dentro dos limites estabelecidos pela empresa.</li><li>Anotar as consultas de clientes relacionadas com mercadorias não disponíveis em estoque.</li><li>Organização e Comunicação:</li><li>Manter seu local de trabalho e áreas em volta, equipamentos organizados e limpos, além de zelar pela conservação e manutenção dos locais de utilização.</li><li>Elaborar e repassar relatórios sob sua responsabilidade nos prazos estipulados.</li></ul>\n<h2><strong>REQUISITOS E QUALIFICAÇÕES</strong></h2>\n<ul><li>Ensino médio completo.</li><li>Paixão por superar metas.</li><li>Boa fluência verbal e habilidade em negociação.</li><li>Postura profissional e senso de organização.</li></ul>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1658411,"hash":"L9V6Y88Y","position_name":"Analista de Vendas - Aço Carbono","description":"<p><strong><strong _msttexthash=\"1135381\" _msthash=\"7031\">Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><strong _msttexthash=\"240318\" _msthash=\"7032\">DESCRIÇÃO DA VAGA</strong><br></p>\n<p _msttexthash=\"87372233\" _msthash=\"7033\">Estamos à procura de um profissional dinâmico e comprometido para a posição de Executivo(a) de Vendas de Aço, que possua experiência com vendas de Aço Carbono. Se você é apaixonado por vendas, tem habilidades de negociação e busca crescimento profissional e deseja fazer parte de uma empresa líder na distribuição de aço e centro de serviços de aço no Brasil, esta pode ser a oportunidade perfeita para você!</p>\n<p _msttexthash=\"364078\" _msthash=\"7034\">Responsabilidades:</p>\n<p></p>\n<ul><li _msttexthash=\"465452\" _msthash=\"7035\">Atendimento ao Cliente:</li><li _msttexthash=\"15889796\" _msthash=\"7036\">Atender clientes, identificando suas necessidades e orientando-os com todas as informações necessárias sobre os produtos disponíveis e sua adequada utilização.</li><li _msttexthash=\"4582344\" _msthash=\"7037\">Analisar sugestões dos clientes sobre o atendimento recebido e os produtos oferecidos.</li><li _msttexthash=\"420875\" _msthash=\"7038\">Estratégia de vendas:</li><li _msttexthash=\"8518445\" _msthash=\"7039\">Observar as práticas da concorrência quanto a preços, ofertas, etc., apresentando sugestões para incrementar as vendas.</li><li _msttexthash=\"8204170\" _msthash=\"7040\">Manter-se bem informado quanto às condições de vendas da empresa e como se comparam com as condições da concorrência.</li><li _msttexthash=\"714896\" _msthash=\"7041\">Negociação e Relacionamento:</li><li _msttexthash=\"9787245\" _msthash=\"7042\">Negociar preços e prazos com clientes, através de propostas escritas e/ou telefone, dentro dos limites estabelecidos pela empresa.</li><li _msttexthash=\"4986618\" _msthash=\"7043\">Anotar as consultas de clientes relacionadas com mercadorias não disponíveis em estoque.</li><li _msttexthash=\"721929\" _msthash=\"7044\">Organização e Comunicação:</li><li _msttexthash=\"13657280\" _msthash=\"7045\">Manter seu local de trabalho e áreas em volta, equipamentos organizados e limpos, além de zelar pela conservação e manutenção dos locais de utilização.</li><li _msttexthash=\"4075305\" _msthash=\"7046\">Elaborar e repassar relatórios sob sua responsabilidade nos prazos estipulados.</li></ul>\n<p _msttexthash=\"176592\" _msthash=\"7047\">Requisitos:</p>\n<ul><li _msttexthash=\"462969\" _msthash=\"7048\">Ensino médio completo.</li><li _msttexthash=\"1709045\" _msthash=\"7049\">Experiência com vendas no segmento de aço carbono.</li><li _msttexthash=\"717743\" _msthash=\"7050\">Possuir veículo próprio e CNH.</li><li _msttexthash=\"711113\" _msthash=\"7051\">Disponibilidade para viagens.</li><li _msttexthash=\"537745\" _msthash=\"7052\">Paixão por superar metas.</li><li _msttexthash=\"1621009\" _msthash=\"7053\">Boa fluência verbal e habilidade em negociação.</li><li _msttexthash=\"1517230\" _msthash=\"7054\">Postura profissional e senso de organização.</li></ul>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:52 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=4","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=2","results":[{"id":1718186,"hash":"QW9WW5W6","position_name":"Analista de QA","description":"<p><strong>Responsabilidades e atribuições:</strong></p>\n<p>-&nbsp;Experiência na análise de teste, incluindo análise de risco e design de testes --&nbsp;Experiência na estratégia de teste, trabalhando em conjunto com os DEVs da equipe no apontamento de quais testes utilizar, como testes funcionais de baixo nível, testes de contrato de serviço e testes de UI.</p>\n<p>- Experiência em testes exploratórios, portando-se como o usuário final do produto, realizando testes de coisas que ainda não estavam descritas como requisitos para serem analisados.</p>\n<p>- Analisar todos os aspectos de utilização do software ou aplicação</p>\n<p>- Verificar se tudo está sendo entregue conforme a expectativa do cliente</p>\n<p>- Orquestrar o trabalho de todos para que tudo saia conforme o esperado, reportando possíveis problemas e buscando melhorias constantes</p>\n<p>- Atuação em projetos de desenvolvimento ágil&nbsp;</p>\n<p><strong>Habilidades:</strong></p>\n<p>- Visão Sistêmica do QA</p>\n<p>- Planejamento e Acompanhamento- Atenção e Foco nas atividades do QA</p>\n<p>- Trabalho em Equipe e Relacionamento Interpessoal</p>\n<p>- Comunicação- Negociação</p>\n<p>- Proatividade</p>\n<p>- Resiliência</p>\n<p>- Gestão de Risco</p>\n<p>Deve ser um profissional sênior com experiência em implantar a área de QA, pois hoje os testes são realizados pelos desenvolvedores, líder técnico e o product owner.</p>\n<p>Não temos ferramenta implantada.</p><p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Informações Adicionais</strong><span style=\"font-family: inherit; font-size: 0.875rem;\">:</span><br></p>\n<ul><li>Presencial: Remoto (Com visitas esporádicas no cliente) </li><li>Contratação PJ</li></ul>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1836259,"hash":"L96XV656","position_name":"Analista de Segurança da Informação Jr","description":"<p>Com mais de 190 lojas no Brasil e na Colômbia, o Grupo desponta no agronegócio como a maior distribuidora de insumos agrícolas da América Latina. Criado a partir da fusão e aquisição de mais de 20 distribuidoras de grande e médio porte, sob o controle do Fundo Pátria Investimentos, o grupo possui marcas próprias de agroquímicos, fertilizantes foliares e biológicos.<br></p>\n<h4>Responsabilidades e Tarefas:</h4>\n<ul><li>Acompanhar as ocorrências de vulnerabilidades e incidentes cibernéticos apontadas pelo SOC.</li><li>Endereçar à infraestrutura de TI as correções das vulnerabilidades levantadas pelo SOC.</li><li>Propor a mitigação dos incidentes cibernéticos encontrados pelo SOC, principalmente os críticos e severos, e colaborar com a infraestrutura de TI para soluções conjuntas.</li></ul>\n<h4>Atividades:</h4>\n<ul><li>Acompanhar as solicitações feitas pelo SOC para mitigar incidentes de cibersegurança.</li><li>Receber as vulnerabilidades apontadas pelo SOC e endereçá-las à infraestrutura de TI para solução via abertura de chamados.</li><li>Homologar ferramentas e fornecedores em projetos relacionados à segurança da informação.</li><li>Realizar assessment de segurança e análise de vulnerabilidades na infraestrutura on-premises e cloud, bem como de aplicações.</li><li>Prestar suporte técnico de nível 3 (troubleshooting) em eventos críticos de segurança.</li></ul>\n<h4>Requisitos Obrigatórios:</h4>\n<ul><li>Forte conhecimento em segurança cibernética e sistemas operacionais Windows e Linux.</li><li>Vivência com times de segurança ofensiva e defensiva.</li><li>Experiência em comunicação e documentação de ameaças identificadas, utilizando métodos e técnicas de exploração.</li><li>Conhecimentos em soluções de segurança como DLP, Firewall, WAF, IPS/IDS, Gestão de Identidade e Acesso (IAM), SIEM, Antivírus, Criptografia e verificação de vulnerabilidades.</li><li>Conhecimentos de arquitetura de redes (TCP/IP, LAN, WAN, VLAN, links e protocolos de comunicação).</li><li>Bons conhecimentos na elaboração e uso de scripts Shell e PowerShell.</li><li>Excelentes conhecimentos de AD 365 ENTRA.</li><li>Ensino Superior em Segurança da Informação ou cursos relacionados.</li></ul>\n<h4>Experiência:</h4>\n<ul><li>Mínimo de 2 anos em redes TCP/IP.</li><li>Conhecimento dos frameworks NIST e MITRE ATT&amp;CK.</li></ul>\n<h4>Conhecimentos Adicionais Desejáveis:</h4>\n<ul><li>Conhecimento da ISO 27001.</li><li>Conhecimento de regramento de firewalls.</li><li>Conhecimento de antivírus EDR/XDR.</li><li>Conhecimento de ferramentas de monitoramento de redes.</li><li>Inglês básico.</li></ul>\n<h4>Informações Complementares:</h4>\n<ul><li>Profissional proativo, capaz de encontrar soluções para eventuais dificuldades e melhorias nos ativos de segurança da informação.</li><li>Capacidade de trabalho em equipe.</li></ul>\n<p><strong>Local de Trabalho:</strong>&nbsp;Híbrido:&nbsp;3 presencial em Curitiba&nbsp;<br><strong>Horário:</strong> Das 08h às 12h e das 13h às 17h48 (plantão/noites e possíveis horas extras)<br><strong>Tipo de Contratação:</strong> CLT ou PJ</p>\n<h4><br>\n\n</h4>","country":"Brazil","state":"PR","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, PR, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1801585,"hash":"QVX3VXW6","position_name":"Analista de Suporte","description":"<p><span dir=\"ltr\" data-redactor-span=\"true\"></span></p><p><strong>Analista de Suporte de TI</strong><br><br><strong>Requisitos e qualificações</strong></p>\n<ul><li>Fornecer suporte técnico presencial a funcionários, solucionando problemas de hardware, software e conectividade de rede de maneira eficaz e amigável.</li><li>Diagnosticar e resolver problemas de TI, incluindo problemas relacionados a sistemas operacionais (Windows, MacOS), redes, hardware de computador e periféricos.</li><li>Desenvolver soluções de automação usando ferramentas do Microsoft Office, como Excel e Power Automate, para otimizar tarefas e melhorar a eficiência operacional.</li><li>Manter registros precisos de tickets de suporte, garantindo que todas as solicitações sejam rastreadas e resolvidas de maneira oportuna.</li><li>Realizar manutenção preventiva em computadores e periféricos, garantindo a estabilidade e a confiabilidade do ambiente de trabalho.</li><li>Treinar os usuários finais sobre melhores práticas de segurança cibernética e uso eficaz da tecnologia.</li><li>Realizar checklist diários aos sistemas de videoconferência instalados nas salas de reunião. Recepcionar e entregar equipamentos para novos colaboradores que estejam entrando na companhia.</li><li>Acionar e acompanhar fornecedores em caso de necessidade Controlar estoque da TI local composto por computadores e celulares.</li><li>Qualificações: Experiência comprovada em suporte técnico presencial e solução de problemas de TI.</li><li>Conhecimento sólido em sistemas operacionais Windows e MacOS.</li><li>Excelentes habilidades de comunicação e capacidade de explicar questões técnicas de forma simples para usuários de diferentes níveis de habilidade.</li><li>Formação em Tecnologia da Informação ou campo relacionado é preferível.</li><li>Forte ética de trabalho, pró-atividade e capacidade de trabalhar tanto de forma independente quanto em equipe</li></ul>\n<p></p>\n<p><strong>Desejáveis</strong></p>\n<ul><li>Colaborar com outros membros da equipe de TI para garantir a integração perfeita de sistemas e a implementação de soluções tecnológicas eficazes.</li><li>Habilidade demonstrada em automatização de tarefas com o Microsoft Office, incluindo Excel e Power Automate.</li><li>Certificações relevantes em suporte técnico de computadores e Microsoft Office.</li><li>Modelo de trabalho: Presencial (Vila Olimpia- SP)</li><li>Tipo de contrato: CLT</li></ul>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1714494,"hash":"L8RV833R","position_name":"Analista de Suporte de TI","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p></p><li>Planejar e executar projetos de TI voltados à infraestrutura.</li><li>Diariamente monitorar o funcionamento de hardwares , links e instalações de TI locais e remotas.</li><li>Realizar atividades de suporte da operação, manutenção preventiva, corretiva e de melhoria contínua nos ativos de TI (ex.: servidores, switches, roteadores, access points, periféricos, e sistemas de automação);</li><li>Visar o pleno funcionamento do parque tecnológico além de atender às exigências das normas do sistema de qualidade e LGPD da empresa.</li><p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></strong></p><p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Obrigatórios</strong></strong><br></p><p>Este profissional deverá ter habilidade em relacionamento com a área de Tecnologia da Informação, capacidade de comunicação com diversos tipos de pessoas e áreas, para contribuir e fazer parcerias com todas as verticais da organização. Possuir visão global sobre funcionalidades e problemas, atuando de forma analítica, raciocínio lógico, pró-atividade, organização e disciplina.<br></p>\n<ul><li>Conhecimento da física e lógica de redes TCP/IP, ranges de IP, subnets/máscaras, gateways, roteamento, topologia de rede e rede óptica.</li><li>Desenvolvimento e acompanhamento de projetos e suas fases (produtos e serviços) em andamento.</li><li>Atendimento aos clientes internos e externos através de dúvidas e necessidades, elaboração de documentação técnica, análise e solução de problemas, atendimento de chamados, atendimento de pedidos via ferramenta de suporte corporativo.</li><li>Conhecimento sistemas operacionais (Windows, Linux);</li><li>Conhecimento em Pacote Office(Word, Excel, PowerPoint), e Office 365.</li><li>Mantém-se informado sobre novas tendências, técnicas, materiais, equipamentos e procedimentos que possam impactar sua atividade;</li><li>Conhecimento em Cloud Azure</li><li>Disponibilidade para viagens entre as unidades.</li></ul>\n<p><strong><strong>﻿Informações Adicionais:&nbsp;&nbsp;<br>﻿</strong></strong>Contratação:&nbsp;CLT<strong><strong>&nbsp;&nbsp;</strong></strong><br>Modelo de trabalho: Presencial em Lorena/SP&nbsp;</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"Lorena","address":"","zipcode":"","location_display":"Lorena, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1789060,"hash":"LR4V7R6R","position_name":"Analista de Suporte N2","description":"<p>Com mais de 190 lojas no Brasil e na Colômbia, o Grupo desponta no Agronegócio como a maior distribuidora de insumos agrícolas da América Latina, foi criada a partir da fusão e aquisição de mais de 20 distribuidoras de grande e médio porte, sob o controle do Fundo Pátria Investimentos. Além disso, o grupo possui marcas próprias de agroquímicos, fertilizantes foliares e biológicos.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong></p>\n<p>Gerenciar a abertura de chamados, gerenciar acessos de usuários, fazer o acompanhamento e monitoramento destes usuários, realizar instalações e configurações de hardware e software e dar suporte técnico aos colaboradores Lavoro.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong></p>\n<ul><li>Experiência em suporte a microinformática;</li><li>Experiência em Windows;</li><li>Experiência, impressoras;</li><li>Experiência em rede.</li></ul>\n<p><strong>Requisitos Complementares﻿</strong></p>\n<ul><li>Ter perfil hands-on.</li></ul><p><strong>Informações Adicionais</strong>:</p>\n<ul><ul><li>Presencial em Curitiba/PR</li><li>Contratação CLT</li></ul></ul>","country":"Brazil","state":"PR","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, PR, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933555,"hash":"L53XY583","position_name":"Analista de Suporte Pleno","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Fornecer suporte aos usuários e ao parque de computadores da empresa, com<br>objetivo de garantir a disponibilidade, estabilidade e atualização constante do<br>ambiente de TI. Acompanhar e executar processos e procedimentos de segurança<br>na rede.<br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>Experiência sólida com operações de TI<br>Suporte a usuários, instalação e configuração de computadores, redes<br>estruturadas, WIFI e roteadores.<br>Conhecimento em ferramentas de backup, virtualização; switches gerenciáveis,<br>Vlan, WIFI e roteadores.<br>Ter disponibilidade de viagens para atender outras unidades.</p>\n<p><strong><strong>O que oferecemos</strong></strong></p><p><strong><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Alimentação no local, seguro de vida, plano de saúde e convênio de farmácia.</span></p>\n<p></p>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716609,"hash":"L7793V93","position_name":"Analista de Testes - JR","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Analista de Testes Júnior desempenha um papel fundamental na equipe de garantia de qualidade, contribuindo para a identificação e resolução de defeitos nos produtos de software. Com um foco em aprendizado contínuo, este profissional apoia a execução de testes, a documentação de resultados e a colaboração com equipes multidisciplinares para assegurar a entrega de software de alta qualidade.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Execução de Testes: Participar ativamente da execução de testes manuais e/ou automatizados, seguindo os casos de teste estabelecidos.</p>\n<p>Documentação de Resultados: Registrar de maneira clara e precisa os resultados dos testes, identificando e documentando defeitos conforme necessário.</p>\n<p>Colaboração com a Equipe: Colaborar com os membros da equipe de desenvolvimento e analistas de teste mais experientes para entender o contexto do software e contribuir para o processo de resolução de defeitos.</p>\n<p>Aprendizado Contínuo: Participar de treinamentos e desenvolvimento profissional para aprimorar as habilidades em testes de software e se manter atualizado com as melhores práticas da indústria.</p>\n<p>Melhoria de Processos: Contribuir para a melhoria contínua dos processos de teste, sugerindo ideias e abordagens inovadoras.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Ciência da Computação, Engenharia de Software, ou áreas relacionadas.</p>\n<p>Familiaridade com conceitos básicos de testes de software.</p>\n<p>Desejo de aprender e crescer na área de garantia de qualidade.</p>\n<p>Habilidade para trabalhar de forma colaborativa em ambientes ágeis.</p>\n<p>Boa capacidade de comunicação verbal e escrita.</p>\n<p>Entre 1 e 2 anos de experiência com testes de software</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Presencial&nbsp;em São José dos Campos/SP&nbsp;</li><li>Contratação PJ</li></ul>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1604349,"hash":"QV7848YR","position_name":"Analista de Vendas","description":"<p><strong><strong _msttexthash=\"1135381\" _msthash=\"6856\">Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><strong _msttexthash=\"240318\" _msthash=\"6857\">DESCRIÇÃO DA VAGA</strong><br></p>\n<p _msttexthash=\"87372233\" _msthash=\"6858\">Estamos à procura de um profissional dinâmico e comprometido para a posição de Executivo(a) de Vendas de Aço, que possua experiência com vendas de Aço Carbono. Se você é apaixonado por vendas, tem habilidades de negociação e busca crescimento profissional e deseja fazer parte de uma empresa líder na distribuição de aço e centro de serviços de aço no Brasil, esta pode ser a oportunidade perfeita para você!</p>\n<h2><strong _msttexthash=\"699088\" _msthash=\"6859\">RESPONSABILIDADES E ATRIBUIÇÕES</strong></h2>\n<p _msttexthash=\"364078\" _msthash=\"6860\">Responsabilidades:</p>\n<p></p>\n<ul><li _msttexthash=\"465452\" _msthash=\"6861\">Atendimento ao Cliente:</li><li _msttexthash=\"15889796\" _msthash=\"6862\">Atender clientes, identificando suas necessidades e orientando-os com todas as informações necessárias sobre os produtos disponíveis e sua adequada utilização.</li><li _msttexthash=\"4582344\" _msthash=\"6863\">Analisar sugestões dos clientes sobre o atendimento recebido e os produtos oferecidos.</li><li _msttexthash=\"420875\" _msthash=\"6864\">Estratégia de vendas:</li><li _msttexthash=\"8518445\" _msthash=\"6865\">Observar as práticas da concorrência quanto a preços, ofertas, etc., apresentando sugestões para incrementar as vendas.</li><li _msttexthash=\"8204170\" _msthash=\"6866\">Manter-se bem informado quanto às condições de vendas da empresa e como se comparam com as condições da concorrência.</li><li _msttexthash=\"714896\" _msthash=\"6867\">Negociação e Relacionamento:</li><li _msttexthash=\"9787245\" _msthash=\"6868\">Negociar preços e prazos com clientes, através de propostas escritas e/ou telefone, dentro dos limites estabelecidos pela empresa.</li><li _msttexthash=\"4986618\" _msthash=\"6869\">Anotar as consultas de clientes relacionadas com mercadorias não disponíveis em estoque.</li><li _msttexthash=\"721929\" _msthash=\"6870\">Organização e Comunicação:</li><li _msttexthash=\"13657280\" _msthash=\"6871\">Manter seu local de trabalho e áreas em volta, equipamentos organizados e limpos, além de zelar pela conservação e manutenção dos locais de utilização.</li><li _msttexthash=\"4075305\" _msthash=\"6872\">Elaborar e repassar relatórios sob sua responsabilidade nos prazos estipulados.</li></ul>\n<h2><strong _msttexthash=\"525785\" _msthash=\"6873\">REQUISITOS E QUALIFICAÇÕES</strong></h2>\n<p _msttexthash=\"176592\" _msthash=\"6874\">Requisitos:</p>\n<ul><li _msttexthash=\"462969\" _msthash=\"6875\">Ensino médio completo.</li><li _msttexthash=\"1709045\" _msthash=\"6876\">Experiência com vendas no segmento de aço carbono.</li><li _msttexthash=\"717743\" _msthash=\"6877\">Possuir veículo próprio e CNH.</li><li _msttexthash=\"711113\" _msthash=\"6878\">Disponibilidade para viagens.</li><li _msttexthash=\"537745\" _msthash=\"6879\">Paixão por superar metas.</li><li _msttexthash=\"1621009\" _msthash=\"6880\">Boa fluência verbal e habilidade em negociação.</li><li _msttexthash=\"1517230\" _msthash=\"6881\">Postura profissional e senso de organização.</li></ul>\n<p></p>\n<p></p>","country":"Brazil","state":"PR","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, PR, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1604077,"hash":"L378368W","position_name":"Analista de Vendas","description":"<p><strong>DESCRIÇÃO DA VAGA</strong></p>\n<p>Estamos à procura de um profissional dinâmico e comprometido para a posição de Analista de Vendas de Aço. Se você é apaixonado por vendas, tem habilidades de negociação e busca crescimento profissional e deseja fazer parte de uma empresa líder na distribuição de aço e centro de serviços de aço no Brasil, esta pode ser a oportunidade perfeita para você!</p>\n<h2><strong>RESPONSABILIDADES E ATRIBUIÇÕES</strong></h2>\n<ul><li>Atendimento ao Cliente:</li><li>Atender clientes, identificando suas necessidades e orientando-os com todas as informações necessárias sobre os produtos disponíveis e sua adequada utilização.</li><li>Analisar sugestões dos clientes sobre o atendimento recebido e os produtos oferecidos.</li><li>Estratégia de vendas:</li><li>Observar as práticas da concorrência quanto a preços, ofertas, etc., apresentando sugestões para incrementar as vendas.</li><li>Manter-se bem informado quanto às condições de vendas da empresa e como se comparam com as condições da concorrência.</li><li>Negociação e Relacionamento:</li><li>Negociar preços e prazos com clientes, através de propostas escritas e/ou telefone, dentro dos limites estabelecidos pela empresa.</li><li>Anotar as consultas de clientes relacionadas com mercadorias não disponíveis em estoque.</li><li>Organização e Comunicação:</li><li>Manter seu local de trabalho e áreas em volta, equipamentos organizados e limpos, além de zelar pela conservação e manutenção dos locais de utilização.</li><li>Elaborar e repassar relatórios sob sua responsabilidade nos prazos estipulados.</li></ul>\n<h2><strong>REQUISITOS E QUALIFICAÇÕES</strong></h2>\n<ul><li>Ensino médio completo.</li><li>Paixão por superar metas.</li><li>Boa fluência verbal e habilidade em negociação.</li><li>Postura profissional e senso de organização.</li></ul>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1658411,"hash":"L9V6Y88Y","position_name":"Analista de Vendas - Aço Carbono","description":"<p><strong><strong _msttexthash=\"1135381\" _msthash=\"7031\">Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><strong _msttexthash=\"240318\" _msthash=\"7032\">DESCRIÇÃO DA VAGA</strong><br></p>\n<p _msttexthash=\"87372233\" _msthash=\"7033\">Estamos à procura de um profissional dinâmico e comprometido para a posição de Executivo(a) de Vendas de Aço, que possua experiência com vendas de Aço Carbono. Se você é apaixonado por vendas, tem habilidades de negociação e busca crescimento profissional e deseja fazer parte de uma empresa líder na distribuição de aço e centro de serviços de aço no Brasil, esta pode ser a oportunidade perfeita para você!</p>\n<p _msttexthash=\"364078\" _msthash=\"7034\">Responsabilidades:</p>\n<p></p>\n<ul><li _msttexthash=\"465452\" _msthash=\"7035\">Atendimento ao Cliente:</li><li _msttexthash=\"15889796\" _msthash=\"7036\">Atender clientes, identificando suas necessidades e orientando-os com todas as informações necessárias sobre os produtos disponíveis e sua adequada utilização.</li><li _msttexthash=\"4582344\" _msthash=\"7037\">Analisar sugestões dos clientes sobre o atendimento recebido e os produtos oferecidos.</li><li _msttexthash=\"420875\" _msthash=\"7038\">Estratégia de vendas:</li><li _msttexthash=\"8518445\" _msthash=\"7039\">Observar as práticas da concorrência quanto a preços, ofertas, etc., apresentando sugestões para incrementar as vendas.</li><li _msttexthash=\"8204170\" _msthash=\"7040\">Manter-se bem informado quanto às condições de vendas da empresa e como se comparam com as condições da concorrência.</li><li _msttexthash=\"714896\" _msthash=\"7041\">Negociação e Relacionamento:</li><li _msttexthash=\"9787245\" _msthash=\"7042\">Negociar preços e prazos com clientes, através de propostas escritas e/ou telefone, dentro dos limites estabelecidos pela empresa.</li><li _msttexthash=\"4986618\" _msthash=\"7043\">Anotar as consultas de clientes relacionadas com mercadorias não disponíveis em estoque.</li><li _msttexthash=\"721929\" _msthash=\"7044\">Organização e Comunicação:</li><li _msttexthash=\"13657280\" _msthash=\"7045\">Manter seu local de trabalho e áreas em volta, equipamentos organizados e limpos, além de zelar pela conservação e manutenção dos locais de utilização.</li><li _msttexthash=\"4075305\" _msthash=\"7046\">Elaborar e repassar relatórios sob sua responsabilidade nos prazos estipulados.</li></ul>\n<p _msttexthash=\"176592\" _msthash=\"7047\">Requisitos:</p>\n<ul><li _msttexthash=\"462969\" _msthash=\"7048\">Ensino médio completo.</li><li _msttexthash=\"1709045\" _msthash=\"7049\">Experiência com vendas no segmento de aço carbono.</li><li _msttexthash=\"717743\" _msthash=\"7050\">Possuir veículo próprio e CNH.</li><li _msttexthash=\"711113\" _msthash=\"7051\">Disponibilidade para viagens.</li><li _msttexthash=\"537745\" _msthash=\"7052\">Paixão por superar metas.</li><li _msttexthash=\"1621009\" _msthash=\"7053\">Boa fluência verbal e habilidade em negociação.</li><li _msttexthash=\"1517230\" _msthash=\"7054\">Postura profissional e senso de organização.</li></ul>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:36 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=4
@@ -350,7 +350,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:52 GMT
+      - Tue, 30 Jul 2024 16:28:37 GMT
       Content-Type:
       - application/json
       Content-Length:
@@ -375,8 +375,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=5","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=3","results":[{"id":1732837,"hash":"QV757RX6","position_name":"Analista do Produto - Arquiteto de Sistemas Eletroeletrônicos Automotivos","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p><ul><li><strong><strong></strong></strong>Definir e gerir requisitos de sistemas eletrônicos para funções veiculares: ADAS, Conectividade, BCM, Cabine e Powertrain;</li><li>Design, desenvolvimento, simulação e validação&nbsp;de modelos em SysML e geração de requisitos de sistemas EE;&nbsp;</li><li>Prover requisitos para desenvolvimento de soluções de&nbsp;HW e SW;</li></ul>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>Formação em engenharia Elétrica, Computação, Mecatrônica ou Controle e automação;</p>\n<p>Experiência em arquitetura,&nbsp;design,&nbsp;implementação e integração&nbsp;de sistemas EE;</p>\n<p>Experiência em especificação de requisitos na área automotiva;</p>\n<p>Conhecimento de metodologias de engenharia de sistemas: MBSE, V-Cycle, AGILE;&nbsp;</p>\n<p>Conhecimento em redes e diagnóstico: CAN, LIN e/ou Ethernet;</p>\n<p>Inglês avançado;</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n(completar)<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de saúde, plano odontológico,&nbsp;auxílio alimentação e auxílio transporte.</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":311607,"hash":"L5WRVR5R","position_name":"Analista do Produto - Benchmarking Powertrain","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li><strong><strong></strong>﻿</strong>Análise de técnica de benchmarking de sistemas de propulsão para&nbsp;veículos HEV e EV;</li><li>Planejamento de atividades (tempo / recursos necessários / custos)<br> Análise de normas e detalhamento de planos de atividades;</li><li>Coordenação de preparação, execução de atividades de testes e&nbsp;teardown dos sistemas de propulsão;<br></li><li>Aquisição, tratamento e análise de dados dos sistemas;</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br></p>\n<ul><li>Engenharia Engenharia Elétrica, Eletrônica, Controle Automação ou afins;</li><li>Conhecimento em&nbsp;Motores elétricos e seus sistemas de controle&nbsp;(inversores de frequência, conversores DC/DC <br>DC/AC e AC/DC),&nbsp;tipos de baterias e tipologias de hibridização veicular;<br></li><li>Experiência em desenvolvimento de motores a combustão, transmissões e sistemas veiculares;</li><li>Experiência em desenvolvimento de sistemas eletroeletrônicos veiculares;</li><li>Software de aquisição e&nbsp;tratamento de dados (INCA, VECTOR,&nbsp;MATLAB ou outro);﻿</li><li>Inglês: Nível Avançado;﻿</li></ul>\n<p><strong><strong>Requisitos Complementar</strong></strong>﻿<strong><strong></strong></strong><br></p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de Saúde, auxílio transporte, auxílio home office, alimentação no site do cliente﻿</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1963182,"hash":"L86V8X3R","position_name":"Analista do Produto - DRE de Sistemas de Conectividade e Infotainment","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p>\n<ul><li>Desenvolver produtos e sistemas&nbsp;na área automotiva com foco em&nbsp;conectividade e entretenimento;</li><li>Interpretar, analisar funções de alto nível de arquitetura de sistemas veiculares;</li><li>Ter como responsabilidade as especificações e a documentação técnica dos produtos;</li><li>Planejar atividades e fazer as entregas no prazo.</li></ul>\n<p><strong><strong>﻿﻿Requisitos Obrigatórios</strong>﻿</strong><br></p>\n<ul><li>Formação em engenharia Elétrica, Eletrônica ou Mecatrônica;</li><li>Experiência em sistemas de infotainment, conectividade, telemática e redes veiculares (CAN);</li><li>Conhecimento sistêmico dos sistemas dos&nbsp;veículos (ex.: ADAS, Comfort, Safety, etc.);</li><li>Experiência em capturar e desenvolver requerimentos técnicos e/ou conteúdos funcionais;</li><li>Um pouco de habilidade para programação/interpretação de&nbsp;softwares e seus requisitos;</li><li>Inglês Avançado;</li><li>Disponibilidade para residir em Belo Horizonte e região;.</li></ul>\n<p><strong><strong>﻿﻿Requisitos complementares não obrigatórios</strong></strong></p>\n<ul><li>﻿Experiência com desenvolvimento de aplicativos Android/IOS;<br></li><li>﻿Experiência com redes, protocolos, linguagens de programação e APIs (ex.: REST, SOAP, JSON,XML);</li><li>Técnico em Eletrônica;</li><li>Conhecimento em Enterprise Architecture;</li><li>Conhecimentos de Redes Veiculares (LIN, Ethernet Automotiva);</li><li>Conhecimento software Doors ou equivalentes;&nbsp;ra preparação de requisitos;</li></ul>\n<p>         </p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde/odontológico, auxílio combustível ou fretado, auxílio alimentação, refeições na planta do cliente e horário híbrido.</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1761519,"hash":"L53V59XR","position_name":"Analista do Produto - Especialista Powertrain (DRE)","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li>Definir requisitos e desenvolver componentes mecânicos para motores a combustão interna;</li><li>Realizar a DFMEA dos componentes;</li><li>Guiar o projetista de CAD no desenvolvimento das peças.</li><li>Conduzir reuniões de revisões de&nbsp;design junto aos fornecedores;</li><li>Emitir a documentação técnica,&nbsp;oficializar desenhos e release final do produto;&nbsp;</li><li><span style=\"font-size: 1em;\">Gerir o plano de testes, realizar&nbsp;análises de problemas e promover discussões técnicas internas.</span></li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Formação em Engenharia Mecânica;</li><li>Inglês avançado;</li><li>Mínimo de 3 anos de experiência no setor automotivo de desenvolvimento de produto.</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p><ul><li>Conhecimento em processos de fabricação de componentes (﻿fundição, estampagem, sinterização, injeção plástica);</li><li>Conhecimento em NX, CATIA e/ou TEAMCENTER;</li><li>Vivência em PLM, preferencialmente Dassault ENOVIA.</li></ul>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de saúde, plano odontológico, auxílio alimentação, auxílio combustível.</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1774012,"hash":"LR4YW4WR","position_name":"Analista do Produto - Experimentação Powertrain (Betim)","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p><ul><li><strong><strong></strong>﻿</strong>Planejar e realizar testes em dinamômetro de motores;</li><li>Acompanhar as atividades de teardown dos motores testados, analisando seus componentes;</li><li>Elaborar relatórios técnicos;</li><li>Atuar na diagnose de problemas técnicos, identificar causa raiz e propor melhorias.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br></p><ul><li>Formação em En<span style=\"font-family: inherit; font-size: 0.875rem;\">genharia Mecânica;</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em motores a combustão interna e seus componentes;</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Experiência na área automotiva em desenvolvimento de motores, preferencialmente na área experimental;</li><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em metodologias \"Problem Solving\"</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Inglês nível avançado</span></li></ul>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong><br>\n(completar)﻿<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, plano odontológico, auxílio alimentação e auxílio transporte</p><p>﻿<br></p>\n<p><br></p><p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1774040,"hash":"QY467499","position_name":"Analista do Produto - Experimentação Powertrain (Pernambuco)","description":"<p>Indústria do setor automotivo</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong>﻿</p>\n<ul><li>Realizar testes de validação&nbsp;em veículos com foco em motores;&nbsp;&nbsp;</li><li>Acompanhar e suportar o processo de diagnose de problemas técnicos, identificando causa raiz e propondo melhorias;&nbsp;</li><li>Elaborar relatórios técnicos;</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong>﻿</p>\n<ul><li>Formação em Engenharia Mecânica;</li><li>Conhecimento em motores a combustão interna e seus componentes;</li><li>Experiência na área automotiva em desenvolvimento de motores, preferencialmente na área experimental;</li><li>Conhecimento em metodologias \"Problem Solving\"</li><li>Inglês nível avançado</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n(completar)<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de saúde, plano odontológico, auxílio alimentação, auxílio transporte</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"PE","city":"Goiana","address":"","zipcode":"","location_display":"Goiana, PE, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1672139,"hash":"QX7V3V5R","position_name":"Analista do Produto - Integrador de Modelos de Controle (Powertrain)","description":"<p><strong>Responsabilidades e Tarefas da Função﻿</strong><br>\nModelagem, simulação e análise de desempenho de veículos híbridos e elétricos&nbsp;por meio de tools, métodos e&nbsp;software. As análises possuem foco em consumo de combustível/energético, aceleração, capacidade de carga, térmica e calibração.&nbsp;</p>\n<p><strong>Requisitos Obrigatórios﻿</strong></p>\n\n\n\n<ul><li>Conhecimento em motores a combustão, transmissões,&nbsp;veículos híbridos e elétricos;</li><li>﻿Vivência na área automotiva, especificamente em desenvolvimentos de sistemas de propulsão.</li><li>Experiência em&nbsp;simulação de moto propulsão, otimização e machine learning;&nbsp;</li><li>Experiência em&nbsp;Python,&nbsp;Matlab, Simulink e Stateflow;﻿</li><li> Formação em engenharia Mecânica, Mecatrônica, Elétrica, Controle Automação ou&nbsp;Computação</li><li>Inglês avançado﻿ - Mandatório;</li></ul>\n<p>Nota: Atividade na modalidade remota&nbsp;</p>\n<p><strong>O que oferecemos﻿</strong><br>\nPlano de saúde, Plano Odontológico, auxílio alimentação, seguro de vida.</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1688909,"hash":"L7735V75","position_name":"Analista do Produto - Performance Powertrain","description":"<p></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<ul><li>Assegurar os objetivos técnicos de performance do produto;</li><li>Liderar equipes multifuncionais para a determinação de causa raiz de falhas de produto/processo e indicação de  correções/melhorias;</li><li>Aquisição, tratamento, análise de dados funcionais de motores a combustão;</li><li>Interface técnica com áreas de engenharia de produto e manufatura para assuntos de durabilidade, calibração, qualidade, performance, NVH;</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Formação em Engenharia Mecânica, Mecatrônica ou Elétrica;</li><li>Conhecimento em motores a combustão, metodologias de qualidade, solução de problemas e processos de manufatura de motores;</li><li>Experiência em análise de objetivos técnicos do produto, tratamento de dados e diagnoses;</li><li>Inglês: Avançado;</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<ul><li>Diferencial: conhecimento e uso de softwares INCA MDA, Matlab, Simulink, CANalyzer e/ou Microsoft Excel;</li></ul>\n<p><strong><strong>O que oferecemos</strong></strong></p>\n<ul><li><strong>Modelo Remoto&nbsp;</strong></li><li><strong></strong>Plano de saúde</li><li>Plano odontológico&nbsp;</li><li>Vale refeição&nbsp;</li></ul>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1732823,"hash":"L9VYV57Y","position_name":"Analista do Produto - Powertrain Calibração","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br>Desenvolvimento de calibração de controle motor e transmissão&nbsp;para sistemas de powertrain. Definição do plano de testes, realização de testes e análise de dados. Preparação de documentação e relatórios técnicos.﻿</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong>﻿</strong></p><ul><li><strong></strong>Formação em Engenharia Mecânica, Elétrica, Mecatrônica ou Controle e Automação.&nbsp;</li><li>Conhecimento em motores de combustão interna, transmissões e sistemas de controle motor.&nbsp;</li><li>Experiência em calibração de motores, transmissões, testes em dinamômetro.&nbsp;</li><li>Conhecimento e uso de softwares: INCA, MATLAB e/ou SIMULINK</li><li>Inglês avançado﻿</li></ul>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong><br>\n(completar)﻿<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, plano odontológico,&nbsp;auxílio alimentação, auxílio transporte</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1653162,"hash":"QW9YRR59","position_name":"Analista do Produto - Project Chief (ADEX)","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li>Coordenação de atividades técnicas e gestão de equipes de desenvolvimento de sistemas eletroeletrônicos.</li><li>Gestão de cronogramas, atividades de Design Review e co-design com fornecedores.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Conhecimento e/ou experiência em sistemas eletrônicos como hardware e software;</li><li>Formação em engenharia Elétrica, Eletrônica ou Mecatrônica;</li><li>Inglês Avançado;</li><li>Será considerado diferencial: experiência em sistemas embarcados automotivos;</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>(completar)<br></p>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.<br></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:52 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=5","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=3","results":[{"id":1732837,"hash":"QV757RX6","position_name":"Analista do Produto - Arquiteto de Sistemas Eletroeletrônicos Automotivos","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p><ul><li><strong><strong></strong></strong>Definir e gerir requisitos de sistemas eletrônicos para funções veiculares: ADAS, Conectividade, BCM, Cabine e Powertrain;</li><li>Design, desenvolvimento, simulação e validação&nbsp;de modelos em SysML e geração de requisitos de sistemas EE;&nbsp;</li><li>Prover requisitos para desenvolvimento de soluções de&nbsp;HW e SW;</li></ul>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>Formação em engenharia Elétrica, Computação, Mecatrônica ou Controle e automação;</p>\n<p>Experiência em arquitetura,&nbsp;design,&nbsp;implementação e integração&nbsp;de sistemas EE;</p>\n<p>Experiência em especificação de requisitos na área automotiva;</p>\n<p>Conhecimento de metodologias de engenharia de sistemas: MBSE, V-Cycle, AGILE;&nbsp;</p>\n<p>Conhecimento em redes e diagnóstico: CAN, LIN e/ou Ethernet;</p>\n<p>Inglês avançado;</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n(completar)<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de saúde, plano odontológico,&nbsp;auxílio alimentação e auxílio transporte.</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":311607,"hash":"L5WRVR5R","position_name":"Analista do Produto - Benchmarking Powertrain","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li><strong><strong></strong>﻿</strong>Análise de técnica de benchmarking de sistemas de propulsão para&nbsp;veículos HEV e EV;</li><li>Planejamento de atividades (tempo / recursos necessários / custos)<br> Análise de normas e detalhamento de planos de atividades;</li><li>Coordenação de preparação, execução de atividades de testes e&nbsp;teardown dos sistemas de propulsão;<br></li><li>Aquisição, tratamento e análise de dados dos sistemas;</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br></p>\n<ul><li>Engenharia Engenharia Elétrica, Eletrônica, Controle Automação ou afins;</li><li>Conhecimento em&nbsp;Motores elétricos e seus sistemas de controle&nbsp;(inversores de frequência, conversores DC/DC <br>DC/AC e AC/DC),&nbsp;tipos de baterias e tipologias de hibridização veicular;<br></li><li>Experiência em desenvolvimento de motores a combustão, transmissões e sistemas veiculares;</li><li>Experiência em desenvolvimento de sistemas eletroeletrônicos veiculares;</li><li>Software de aquisição e&nbsp;tratamento de dados (INCA, VECTOR,&nbsp;MATLAB ou outro);﻿</li><li>Inglês: Nível Avançado;﻿</li></ul>\n<p><strong><strong>Requisitos Complementar</strong></strong>﻿<strong><strong></strong></strong><br></p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de Saúde, auxílio transporte, auxílio home office, alimentação no site do cliente﻿</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1963182,"hash":"L86V8X3R","position_name":"Analista do Produto - DRE de Sistemas de Conectividade e Infotainment","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p>\n<ul><li>Desenvolver produtos e sistemas&nbsp;na área automotiva com foco em&nbsp;conectividade e entretenimento;</li><li>Interpretar, analisar funções de alto nível de arquitetura de sistemas veiculares;</li><li>Ter como responsabilidade as especificações e a documentação técnica dos produtos;</li><li>Planejar atividades e fazer as entregas no prazo.</li></ul>\n<p><strong><strong>﻿﻿Requisitos Obrigatórios</strong>﻿</strong><br></p>\n<ul><li>Formação em engenharia Elétrica, Eletrônica ou Mecatrônica;</li><li>Experiência em sistemas de infotainment, conectividade, telemática e redes veiculares (CAN);</li><li>Conhecimento sistêmico dos sistemas dos&nbsp;veículos (ex.: ADAS, Comfort, Safety, etc.);</li><li>Experiência em capturar e desenvolver requerimentos técnicos e/ou conteúdos funcionais;</li><li>Um pouco de habilidade para programação/interpretação de&nbsp;softwares e seus requisitos;</li><li>Inglês Avançado;</li><li>Disponibilidade para residir em Belo Horizonte e região;.</li></ul>\n<p><strong><strong>﻿﻿Requisitos complementares não obrigatórios</strong></strong></p>\n<ul><li>﻿Experiência com desenvolvimento de aplicativos Android/IOS;<br></li><li>﻿Experiência com redes, protocolos, linguagens de programação e APIs (ex.: REST, SOAP, JSON,XML);</li><li>Técnico em Eletrônica;</li><li>Conhecimento em Enterprise Architecture;</li><li>Conhecimentos de Redes Veiculares (LIN, Ethernet Automotiva);</li><li>Conhecimento software Doors ou equivalentes;&nbsp;ra preparação de requisitos;</li></ul>\n<p>         </p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde/odontológico, auxílio combustível ou fretado, auxílio alimentação, refeições na planta do cliente e horário híbrido.</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1761519,"hash":"L53V59XR","position_name":"Analista do Produto - Especialista Powertrain (DRE)","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li>Definir requisitos e desenvolver componentes mecânicos para motores a combustão interna;</li><li>Realizar a DFMEA dos componentes;</li><li>Guiar o projetista de CAD no desenvolvimento das peças.</li><li>Conduzir reuniões de revisões de&nbsp;design junto aos fornecedores;</li><li>Emitir a documentação técnica,&nbsp;oficializar desenhos e release final do produto;&nbsp;</li><li><span style=\"font-size: 1em;\">Gerir o plano de testes, realizar&nbsp;análises de problemas e promover discussões técnicas internas.</span></li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Formação em Engenharia Mecânica;</li><li>Inglês avançado;</li><li>Mínimo de 3 anos de experiência no setor automotivo de desenvolvimento de produto.</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p><ul><li>Conhecimento em processos de fabricação de componentes (﻿fundição, estampagem, sinterização, injeção plástica);</li><li>Conhecimento em NX, CATIA e/ou TEAMCENTER;</li><li>Vivência em PLM, preferencialmente Dassault ENOVIA.</li></ul>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de saúde, plano odontológico, auxílio alimentação, auxílio combustível.</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1774012,"hash":"LR4YW4WR","position_name":"Analista do Produto - Experimentação Powertrain (Betim)","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p><ul><li><strong><strong></strong>﻿</strong>Planejar e realizar testes em dinamômetro de motores;</li><li>Acompanhar as atividades de teardown dos motores testados, analisando seus componentes;</li><li>Elaborar relatórios técnicos;</li><li>Atuar na diagnose de problemas técnicos, identificar causa raiz e propor melhorias.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br></p><ul><li>Formação em En<span style=\"font-family: inherit; font-size: 0.875rem;\">genharia Mecânica;</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em motores a combustão interna e seus componentes;</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span>Experiência na área automotiva em desenvolvimento de motores, preferencialmente na área experimental;</li><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em metodologias \"Problem Solving\"</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\">Inglês nível avançado</span></li></ul>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong><br>\n(completar)﻿<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, plano odontológico, auxílio alimentação e auxílio transporte</p><p>﻿<br></p>\n<p><br></p><p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1774040,"hash":"QY467499","position_name":"Analista do Produto - Experimentação Powertrain (Pernambuco)","description":"<p>Indústria do setor automotivo</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong>﻿</p>\n<ul><li>Realizar testes de validação&nbsp;em veículos com foco em motores;&nbsp;&nbsp;</li><li>Acompanhar e suportar o processo de diagnose de problemas técnicos, identificando causa raiz e propondo melhorias;&nbsp;</li><li>Elaborar relatórios técnicos;</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong>﻿</p>\n<ul><li>Formação em Engenharia Mecânica;</li><li>Conhecimento em motores a combustão interna e seus componentes;</li><li>Experiência na área automotiva em desenvolvimento de motores, preferencialmente na área experimental;</li><li>Conhecimento em metodologias \"Problem Solving\"</li><li>Inglês nível avançado</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n(completar)<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de saúde, plano odontológico, auxílio alimentação, auxílio transporte</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"PE","city":"Goiana","address":"","zipcode":"","location_display":"Goiana, PE, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1672139,"hash":"QX7V3V5R","position_name":"Analista do Produto - Integrador de Modelos de Controle (Powertrain)","description":"<p><strong>Responsabilidades e Tarefas da Função﻿</strong><br>\nModelagem, simulação e análise de desempenho de veículos híbridos e elétricos&nbsp;por meio de tools, métodos e&nbsp;software. As análises possuem foco em consumo de combustível/energético, aceleração, capacidade de carga, térmica e calibração.&nbsp;</p>\n<p><strong>Requisitos Obrigatórios﻿</strong></p>\n\n\n\n<ul><li>Conhecimento em motores a combustão, transmissões,&nbsp;veículos híbridos e elétricos;</li><li>﻿Vivência na área automotiva, especificamente em desenvolvimentos de sistemas de propulsão.</li><li>Experiência em&nbsp;simulação de moto propulsão, otimização e machine learning;&nbsp;</li><li>Experiência em&nbsp;Python,&nbsp;Matlab, Simulink e Stateflow;﻿</li><li> Formação em engenharia Mecânica, Mecatrônica, Elétrica, Controle Automação ou&nbsp;Computação</li><li>Inglês avançado﻿ - Mandatório;</li></ul>\n<p>Nota: Atividade na modalidade remota&nbsp;</p>\n<p><strong>O que oferecemos﻿</strong><br>\nPlano de saúde, Plano Odontológico, auxílio alimentação, seguro de vida.</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1688909,"hash":"L7735V75","position_name":"Analista do Produto - Performance Powertrain","description":"<p></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<ul><li>Assegurar os objetivos técnicos de performance do produto;</li><li>Liderar equipes multifuncionais para a determinação de causa raiz de falhas de produto/processo e indicação de  correções/melhorias;</li><li>Aquisição, tratamento, análise de dados funcionais de motores a combustão;</li><li>Interface técnica com áreas de engenharia de produto e manufatura para assuntos de durabilidade, calibração, qualidade, performance, NVH;</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Formação em Engenharia Mecânica, Mecatrônica ou Elétrica;</li><li>Conhecimento em motores a combustão, metodologias de qualidade, solução de problemas e processos de manufatura de motores;</li><li>Experiência em análise de objetivos técnicos do produto, tratamento de dados e diagnoses;</li><li>Inglês: Avançado;</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<ul><li>Diferencial: conhecimento e uso de softwares INCA MDA, Matlab, Simulink, CANalyzer e/ou Microsoft Excel;</li></ul>\n<p><strong><strong>O que oferecemos</strong></strong></p>\n<ul><li><strong>Modelo Remoto&nbsp;</strong></li><li><strong></strong>Plano de saúde</li><li>Plano odontológico&nbsp;</li><li>Vale refeição&nbsp;</li></ul>\n<p></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1732823,"hash":"L9VYV57Y","position_name":"Analista do Produto - Powertrain Calibração","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br>Desenvolvimento de calibração de controle motor e transmissão&nbsp;para sistemas de powertrain. Definição do plano de testes, realização de testes e análise de dados. Preparação de documentação e relatórios técnicos.﻿</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong>﻿</strong></p><ul><li><strong></strong>Formação em Engenharia Mecânica, Elétrica, Mecatrônica ou Controle e Automação.&nbsp;</li><li>Conhecimento em motores de combustão interna, transmissões e sistemas de controle motor.&nbsp;</li><li>Experiência em calibração de motores, transmissões, testes em dinamômetro.&nbsp;</li><li>Conhecimento e uso de softwares: INCA, MATLAB e/ou SIMULINK</li><li>Inglês avançado﻿</li></ul>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong><br>\n(completar)﻿<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, plano odontológico,&nbsp;auxílio alimentação, auxílio transporte</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1653162,"hash":"QW9YRR59","position_name":"Analista do Produto - Project Chief (ADEX)","description":"<p>Indústria do setor automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li>Coordenação de atividades técnicas e gestão de equipes de desenvolvimento de sistemas eletroeletrônicos.</li><li>Gestão de cronogramas, atividades de Design Review e co-design com fornecedores.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Conhecimento e/ou experiência em sistemas eletrônicos como hardware e software;</li><li>Formação em engenharia Elétrica, Eletrônica ou Mecatrônica;</li><li>Inglês Avançado;</li><li>Será considerado diferencial: experiência em sistemas embarcados automotivos;</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>(completar)<br></p>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.<br></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:37 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=5
@@ -396,7 +396,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:53 GMT
+      - Tue, 30 Jul 2024 16:28:38 GMT
       Content-Type:
       - application/json
       Content-Length:
@@ -421,8 +421,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=6","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=4","results":[{"id":1944086,"hash":"QWYVVXY6","position_name":"Analista do Produto - Project Chief para time de Conectividade e Infotainment","description":"<p>Indústria do Setor Automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<ul><li>Coordenação de atividades técnicas e gestão de equipes de desenvolvimento de sistemas eletroeletrônicos.</li><li>Gestão de cronogramas, atividades de Design Review e co-design com fornecedores.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Conhecimento e/ou experiência em sistemas eletrônicos como hardware e software;</li><li>Formação em engenharia Elétrica, Eletrônica ou Mecatrônica;</li><li>Inglês Avançado;</li><li>Será considerado diferencial: experiência em gestão de projetos em sistemas embarcados automotivos.</li></ul>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959826,"hash":"QWYW93WW","position_name":"API Arquitect","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um API Arquitect&nbsp;para reforçar a nossa equipa, em regime híbrido.</span></p>\n<p>Este Arquitect será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer o desenvolvimento de soluções e componentes core, que aumentem a eficiência das equipas de desenvolvimento.</li><li>Supervisionar e dar suporte técnico a equipas de desenvolvimento.</li><li>Criar e capacitar equipas de desenvolvimento para implementação das boas práticas de desenvolvimento.</li><li>Analisar e executar atividades de&nbsp;rework ou de implementação de melhorias no código (redução de dívida técnica).</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +2 anos com desenvolvimento de&nbsp;APIs.</li><li>Experiência mínima de +1 ano desenvolvimento de SOAP e REST API.</li><li>Conhecimentos de DevOps, CI/CD&nbsp;(preferencialmente Jenkins)</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828721,"hash":"L76V4W55","position_name":"Assembly Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Assembly Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p><strong><br></strong></p>\n<p><strong></strong><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in assembly lines or assembly equipment</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1848495,"hash":"L9673854","position_name":"Assistente Project Manager","description":"<p>Junte-se a família PTC Group 🤩<br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙<br></p>\n<p>Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀<br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul>\n <li>Participação de reuniões      junto a plataforma para acompanhar a gestão dos projetos.</li>\n <li>Interface com outras      funções e áreas da empresa.</li>\n <li> Controle das      documentações técnicas de modificação (CCDs/ODMs).</li>\n <li>Planejamento e      acompanhamento das atividades de desenvolvimento do projeto (Steps), TKOs,      Validações, etc.</li>\n</ul>\n<p><strong>Perfil:</strong></p>\n<ul>\n <li>Necessário experiência e      conhecimento dos processos de desenvolvimento do produto e      sistemas Stellantis: Codep, CCDs, MAPS.</li>\n <li>Desejável inglês</li>\n <li>Pacote Office</li>\n</ul>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1676737,"hash":"QV79V4W6","position_name":"Atendimento Pós-venda","description":"<p><br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br>\nÁrea de pós venda em empresa internacional líder de mercado; Especialização profissional de preferência: comércio nacional e exterior, importação e exportação. Será responsável de departamento e suas principais funções são:<br>1. Gerar ofertas comerciais de acordo com os parâmetros estabelecidos.<br>2. Gerar ofertas de sugestões de peças de reposição conforme relatórios de visitas técnicas e/ou solicitações de clientes.<br>3. Realizar monitoramento e rastreabilidade das compras nacionais e internacionais de acordo com os termos de negociação do INCOTERM, requisitos logísticos e aduaneiros.<br>4. Acompanhar os órgãos aduaneiros nos processos terceirizados de nacionalização.<br>5. Planejar, consolidar e gerar pedidos de compra.<br>6. Controlar e manter a reposição do estoque de peças de reposição no almoxarifado.<br>7. Preparar, embalar e enviar mercadorias do cliente.<br>8. Coordenar o transporte nacional e internacional.<br>9. Prestar aconselhamento técnico e comercial ao cliente para a correta utilização e melhor desempenho dos consumíveis fornecidos.<br>10. Elaborar relatórios de vendas, backlog, ofertas enviadas, gestão de ofertas e inventário mensal.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\nExperiência na área industrial e logística, (validada por trabalhos anteriores)<br>Proficiência em inglês e espanhol<br>Habilidades: Trabalhar sob pressão, Excel.<br><br></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\nCom noções de contabilidade aplicadas a pós venda;<br>﻿﻿Formação em&nbsp;Engenheiro Industrial e/ou áreas correlatas ao cargo<br>Disponibilidade para viajar<strong><strong></strong></strong></p>\n<p><br></p>\n<p><strong><strong><br></strong></strong></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828772,"hash":"LR4RV73X","position_name":"Automation Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Automation Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus.</li><li>Experience programmable automatons, PLCs and Automated Guided Vehicles (AGVs) systems and equipment﻿</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1714877,"hash":"L374Y348","position_name":"Automotive MTM (Methods-Time Measurement) Engineer","description":"<p><strong>Position: Automotive MTM (Methods-Time Measurement) Engineer</strong></p>\n<p><strong>Location: Viana do Castelo, Portugal</strong></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">At PTC, we are looking to strengthen our \"Operational Efficiency and Continuous Improvement\" team with an MTM (Methods-Time Measurement) Engineer, experienced in the AUTOMOTIVE sector, to work on a significant project for our TIER-1 client located in Viana do Castelo.</span></p><p><strong><br></strong></p><p><strong><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Tasks and Responsibilities:</span></strong></p>\n\n\n\n\n\n\n\n<ul><li>Creation and adaptation of assembly lines to improve productivity</li><li>Time management on manufacturing lines</li><li>Time analysis and measurement using MTM (Methods-Time Measurement)</li><li>Balancing workstations to optimize efficiency</li><li>Support in the design of new parts, considering feasibility, ergonomics, and repeatability</li><li>Specification and technical documentation of the assembly process, including manual tools and coding of engineering times</li><li>Development and implementation of manual tools at the manufacturing site</li><li>Sizing of assembly lines to ensure efficient operation</li></ul><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requirements:</strong></span></p>\n\n\n\n\n\n\n<ul><li>Education as Higher Technician, Bachelor's Degree in Industrial Engineering or similar</li><li>Relevant experience between 3 to 5 years</li><li>Specific experience in the preparation of mechanical assembly lines in the automotive sector, including job balancing</li><li>Knowledge of metal parts subassemblies is desirable</li><li>MTM 1 and MTM 2 certification is an advantage</li><li>Proficiency in MS Office and MS Project</li><li>Fluency in Portuguese OR Spanish; intermediate English</li></ul>","country":"Portugal","state":"Viana do Castelo District","city":"Viana do Castelo","address":"","zipcode":"","location_display":"Viana do Castelo, Viana do Castelo District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1767523,"hash":"L963RW76","position_name":"Avionics Pure Systems Engineer","description":"<p><strong>Location:</strong> On-site in Evora, Portugal</p>\n<p><strong>Experience Level:</strong> Intermediate to Senior (Minimum 5 years of experience)</p>\n<p>We are hiring for our client company that develops and operates innovative products in mobility industries, specifically in Automotive and Urban Mobility, Aerospace, Ocean, and Space.</p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong><br></strong></span></p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong>Responsibilities:</strong></span></p><ul><li><span style=\"font-size: 1em; font-family: inherit;\"></span><span style=\"font-size: 1em;\">Analyze and refine requirements with cross-functional teams.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Develop system solutions using MBSE and trade-off analyses.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Manage systems integration, interfaces, and baseline control, including configuration and change control.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Define test plans and tools for system validation and acceptance.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Create systems engineering documentation (management plans, reports, etc.).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Support technical management, project governance, and risk/opportunity management.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Assist in systems security and aircraft certification.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Collaborate to improve tools, processes, and share knowledge.</span></li></ul><p><strong><br></strong></p><p><strong><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Requirements:</span></strong></p><ul><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">M.Sc. in Aerospace, Mechanical, Electrical Engineering, or similar field.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Experience in aircraft system engineering (requirement management, system architecture, MBSE, verification and validation, technical management, configuration control).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Proficiency in defining mechanical and electrical interfaces (pure systems).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Hands-on experience with requirement management tools (IBM Doors or similar) and MBSE tools (CAMEO, CAPELLA, Enterprise Architect).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Knowledge in UML/SysML, Python, Matlab/Simulink, or similar system modeling software.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Strong interpersonal skills, ability to work both independently and in teams.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Fluency in Portuguese and/or English.</span></li></ul>","country":"Portugal","state":"Évora District","city":"Evora","address":"","zipcode":"","location_display":"Evora, Évora District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1953013,"hash":"QVXV33X6","position_name":"Backend Developer (Golang)","description":"<p><span style=\"font-size: 13.86px;\">A PTC Group está a recrutar um Backend Developer com conhecimentos em Go (Goland) e/ou PHP </span><span style=\"font-size: 13.86px; background-color: rgb(245, 245, 245); float: none; display: inline !important;\">para se juntar à nossa equipa.</span><span style=\"font-size: 13.86px;\"></span></p>\n<p style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">O Backend Developer será responsável por:</p>\n<p style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><strong style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><strong style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">Responsabilidades:</strong></strong></p><li>Desenvolver e melhorar plataformas Backend com recurso a&nbsp;Golang e/ou PHP.</li><li>Garantir uma cobertura de testes, bem como diagnosticar e resolver problemas.</li><li>Participar na revisão de código e colaborar com outros Developers de Engenharia de Backend para assegurar a qualidade do código.</li><li>Criar e manter documentação técnica clara e precisa para o código e sistemas desenvolvidos.</li><li>Colaborar com outras equipas, como Frontend e Data, para garantir a integração entre os vários sistemas.</li>\n<p></p>\n<p><strong><strong>Requisitos:</strong></strong></p><ul><li>Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +1 anos com Golang.</li><li>Conhecimentos em PHP,&nbsp;para contextos legados.</li><li>Experiência com metodologias ágeis como o Scrum.</li></ul><ul><li>Conhecimentos em ferramentas CI/CD (nice-to-have).</li><li>Experiência com Cloud como AWS&nbsp;(nice-to-have).</li><li>Experiência&nbsp; com&nbsp;databases como MySQL e MongoDB (nice-to-have).</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1583512,"hash":"LRWRRR4R","position_name":"Banco de talentos- Analista de desenvolvimento de produto","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Atividades:</strong></p>\n<p>Gerenciar o desenvolvimento de cada componente/subsistema a evolução das fases de desenvolvimento, cumprindo os prazos e as metas estabelecidas. (custo, performance, qualidade). Além disso é responsável pela integração dos entes envolvidos no processo de forma a garantir a entrada em produção das peças sob sua responsabilidade no prazo e na qualidade estabelecida. Também é responsável pela elaboração de toda a documentação técnica relativa ao seu perímetro bem como sua divulgação e/ou cumprimento antes e depois da entrada em produção do veículo.</p>\n<p><strong>Necessário:</strong></p>\n<p>Formação em Engenharia</p>\n<p>Disponibilidade para viagem e trabalho presencial</p>\n<p>Inglês nível intermediário</p>\n<p>Experiência anterior no segmento automotivo</p>\n<p><strong>Diferenciais: </strong></p>\n<p>Inglês nível avançado</p>\n<p>Pós-graduação em Gerenciamento de Projeto</p>\n<p>Experiência anterior em processos de fabricação</p>\n<p><strong>Áreas de interesse:</strong></p>\n<p>Chassis</p>\n<p>Carroceria</p>\n<p>Acabamento interno</p>\n<p>Acabamento externo</p><p></p><p>﻿<br></p>\n<p><br></p><p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:53 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=6","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=4","results":[{"id":1944086,"hash":"QWYVVXY6","position_name":"Analista do Produto - Project Chief para time de Conectividade e Infotainment","description":"<p>Indústria do Setor Automotivo<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<ul><li>Coordenação de atividades técnicas e gestão de equipes de desenvolvimento de sistemas eletroeletrônicos.</li><li>Gestão de cronogramas, atividades de Design Review e co-design com fornecedores.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Conhecimento e/ou experiência em sistemas eletrônicos como hardware e software;</li><li>Formação em engenharia Elétrica, Eletrônica ou Mecatrônica;</li><li>Inglês Avançado;</li><li>Será considerado diferencial: experiência em gestão de projetos em sistemas embarcados automotivos.</li></ul>\n<p><strong>O que oferecemos</strong><br>Plano de saúde, auxílio combustível, auxílio alimentação, refeições na planta do cliente e regime de trabalho híbrido.</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959826,"hash":"QWYW93WW","position_name":"API Arquitect","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um API Arquitect&nbsp;para reforçar a nossa equipa, em regime híbrido.</span></p>\n<p>Este Arquitect será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer o desenvolvimento de soluções e componentes core, que aumentem a eficiência das equipas de desenvolvimento.</li><li>Supervisionar e dar suporte técnico a equipas de desenvolvimento.</li><li>Criar e capacitar equipas de desenvolvimento para implementação das boas práticas de desenvolvimento.</li><li>Analisar e executar atividades de&nbsp;rework ou de implementação de melhorias no código (redução de dívida técnica).</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +2 anos com desenvolvimento de&nbsp;APIs.</li><li>Experiência mínima de +1 ano desenvolvimento de SOAP e REST API.</li><li>Conhecimentos de DevOps, CI/CD&nbsp;(preferencialmente Jenkins)</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828721,"hash":"L76V4W55","position_name":"Assembly Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Assembly Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p><strong><br></strong></p>\n<p><strong></strong><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in assembly lines or assembly equipment</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1848495,"hash":"L9673854","position_name":"Assistente Project Manager","description":"<p>Junte-se a família PTC Group 🤩<br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙<br></p>\n<p>Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀<br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul>\n <li>Participação de reuniões      junto a plataforma para acompanhar a gestão dos projetos.</li>\n <li>Interface com outras      funções e áreas da empresa.</li>\n <li> Controle das      documentações técnicas de modificação (CCDs/ODMs).</li>\n <li>Planejamento e      acompanhamento das atividades de desenvolvimento do projeto (Steps), TKOs,      Validações, etc.</li>\n</ul>\n<p><strong>Perfil:</strong></p>\n<ul>\n <li>Necessário experiência e      conhecimento dos processos de desenvolvimento do produto e      sistemas Stellantis: Codep, CCDs, MAPS.</li>\n <li>Desejável inglês</li>\n <li>Pacote Office</li>\n</ul>\n<p></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1676737,"hash":"QV79V4W6","position_name":"Atendimento Pós-venda","description":"<p><br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br>\nÁrea de pós venda em empresa internacional líder de mercado; Especialização profissional de preferência: comércio nacional e exterior, importação e exportação. Será responsável de departamento e suas principais funções são:<br>1. Gerar ofertas comerciais de acordo com os parâmetros estabelecidos.<br>2. Gerar ofertas de sugestões de peças de reposição conforme relatórios de visitas técnicas e/ou solicitações de clientes.<br>3. Realizar monitoramento e rastreabilidade das compras nacionais e internacionais de acordo com os termos de negociação do INCOTERM, requisitos logísticos e aduaneiros.<br>4. Acompanhar os órgãos aduaneiros nos processos terceirizados de nacionalização.<br>5. Planejar, consolidar e gerar pedidos de compra.<br>6. Controlar e manter a reposição do estoque de peças de reposição no almoxarifado.<br>7. Preparar, embalar e enviar mercadorias do cliente.<br>8. Coordenar o transporte nacional e internacional.<br>9. Prestar aconselhamento técnico e comercial ao cliente para a correta utilização e melhor desempenho dos consumíveis fornecidos.<br>10. Elaborar relatórios de vendas, backlog, ofertas enviadas, gestão de ofertas e inventário mensal.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\nExperiência na área industrial e logística, (validada por trabalhos anteriores)<br>Proficiência em inglês e espanhol<br>Habilidades: Trabalhar sob pressão, Excel.<br><br></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\nCom noções de contabilidade aplicadas a pós venda;<br>﻿﻿Formação em&nbsp;Engenheiro Industrial e/ou áreas correlatas ao cargo<br>Disponibilidade para viajar<strong><strong></strong></strong></p>\n<p><br></p>\n<p><strong><strong><br></strong></strong></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828772,"hash":"LR4RV73X","position_name":"Automation Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Automation Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus.</li><li>Experience programmable automatons, PLCs and Automated Guided Vehicles (AGVs) systems and equipment﻿</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1714877,"hash":"L374Y348","position_name":"Automotive MTM (Methods-Time Measurement) Engineer","description":"<p><strong>Position: Automotive MTM (Methods-Time Measurement) Engineer</strong></p>\n<p><strong>Location: Viana do Castelo, Portugal</strong></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">At PTC, we are looking to strengthen our \"Operational Efficiency and Continuous Improvement\" team with an MTM (Methods-Time Measurement) Engineer, experienced in the AUTOMOTIVE sector, to work on a significant project for our TIER-1 client located in Viana do Castelo.</span></p><p><strong><br></strong></p><p><strong><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Tasks and Responsibilities:</span></strong></p>\n\n\n\n\n\n\n\n<ul><li>Creation and adaptation of assembly lines to improve productivity</li><li>Time management on manufacturing lines</li><li>Time analysis and measurement using MTM (Methods-Time Measurement)</li><li>Balancing workstations to optimize efficiency</li><li>Support in the design of new parts, considering feasibility, ergonomics, and repeatability</li><li>Specification and technical documentation of the assembly process, including manual tools and coding of engineering times</li><li>Development and implementation of manual tools at the manufacturing site</li><li>Sizing of assembly lines to ensure efficient operation</li></ul><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requirements:</strong></span></p>\n\n\n\n\n\n\n<ul><li>Education as Higher Technician, Bachelor's Degree in Industrial Engineering or similar</li><li>Relevant experience between 3 to 5 years</li><li>Specific experience in the preparation of mechanical assembly lines in the automotive sector, including job balancing</li><li>Knowledge of metal parts subassemblies is desirable</li><li>MTM 1 and MTM 2 certification is an advantage</li><li>Proficiency in MS Office and MS Project</li><li>Fluency in Portuguese OR Spanish; intermediate English</li></ul>","country":"Portugal","state":"Viana do Castelo District","city":"Viana do Castelo","address":"","zipcode":"","location_display":"Viana do Castelo, Viana do Castelo District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1767523,"hash":"L963RW76","position_name":"Avionics Pure Systems Engineer","description":"<p><strong>Location:</strong> On-site in Evora, Portugal</p>\n<p><strong>Experience Level:</strong> Intermediate to Senior (Minimum 5 years of experience)</p>\n<p>We are hiring for our client company that develops and operates innovative products in mobility industries, specifically in Automotive and Urban Mobility, Aerospace, Ocean, and Space.</p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong><br></strong></span></p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong>Responsibilities:</strong></span></p><ul><li><span style=\"font-size: 1em; font-family: inherit;\"></span><span style=\"font-size: 1em;\">Analyze and refine requirements with cross-functional teams.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Develop system solutions using MBSE and trade-off analyses.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Manage systems integration, interfaces, and baseline control, including configuration and change control.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Define test plans and tools for system validation and acceptance.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Create systems engineering documentation (management plans, reports, etc.).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Support technical management, project governance, and risk/opportunity management.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Assist in systems security and aircraft certification.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Collaborate to improve tools, processes, and share knowledge.</span></li></ul><p><strong><br></strong></p><p><strong><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Requirements:</span></strong></p><ul><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">M.Sc. in Aerospace, Mechanical, Electrical Engineering, or similar field.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Experience in aircraft system engineering (requirement management, system architecture, MBSE, verification and validation, technical management, configuration control).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Proficiency in defining mechanical and electrical interfaces (pure systems).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Hands-on experience with requirement management tools (IBM Doors or similar) and MBSE tools (CAMEO, CAPELLA, Enterprise Architect).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Knowledge in UML/SysML, Python, Matlab/Simulink, or similar system modeling software.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Strong interpersonal skills, ability to work both independently and in teams.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Fluency in Portuguese and/or English.</span></li></ul>","country":"Portugal","state":"Évora District","city":"Evora","address":"","zipcode":"","location_display":"Evora, Évora District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1953013,"hash":"QVXV33X6","position_name":"Backend Developer (Golang)","description":"<p><span style=\"font-size: 13.86px;\">A PTC Group está a recrutar um Backend Developer com conhecimentos em Go (Goland) e/ou PHP </span><span style=\"font-size: 13.86px; background-color: rgb(245, 245, 245); float: none; display: inline !important;\">para se juntar à nossa equipa.</span><span style=\"font-size: 13.86px;\"></span></p>\n<p style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">O Backend Developer será responsável por:</p>\n<p style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><strong style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><strong style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">Responsabilidades:</strong></strong></p><li>Desenvolver e melhorar plataformas Backend com recurso a&nbsp;Golang e/ou PHP.</li><li>Garantir uma cobertura de testes, bem como diagnosticar e resolver problemas.</li><li>Participar na revisão de código e colaborar com outros Developers de Engenharia de Backend para assegurar a qualidade do código.</li><li>Criar e manter documentação técnica clara e precisa para o código e sistemas desenvolvidos.</li><li>Colaborar com outras equipas, como Frontend e Data, para garantir a integração entre os vários sistemas.</li>\n<p></p>\n<p><strong><strong>Requisitos:</strong></strong></p><ul><li>Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +1 anos com Golang.</li><li>Conhecimentos em PHP,&nbsp;para contextos legados.</li><li>Experiência com metodologias ágeis como o Scrum.</li></ul><ul><li>Conhecimentos em ferramentas CI/CD (nice-to-have).</li><li>Experiência com Cloud como AWS&nbsp;(nice-to-have).</li><li>Experiência&nbsp; com&nbsp;databases como MySQL e MongoDB (nice-to-have).</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1583512,"hash":"LRWRRR4R","position_name":"Banco de talentos- Analista de desenvolvimento de produto","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Atividades:</strong></p>\n<p>Gerenciar o desenvolvimento de cada componente/subsistema a evolução das fases de desenvolvimento, cumprindo os prazos e as metas estabelecidas. (custo, performance, qualidade). Além disso é responsável pela integração dos entes envolvidos no processo de forma a garantir a entrada em produção das peças sob sua responsabilidade no prazo e na qualidade estabelecida. Também é responsável pela elaboração de toda a documentação técnica relativa ao seu perímetro bem como sua divulgação e/ou cumprimento antes e depois da entrada em produção do veículo.</p>\n<p><strong>Necessário:</strong></p>\n<p>Formação em Engenharia</p>\n<p>Disponibilidade para viagem e trabalho presencial</p>\n<p>Inglês nível intermediário</p>\n<p>Experiência anterior no segmento automotivo</p>\n<p><strong>Diferenciais: </strong></p>\n<p>Inglês nível avançado</p>\n<p>Pós-graduação em Gerenciamento de Projeto</p>\n<p>Experiência anterior em processos de fabricação</p>\n<p><strong>Áreas de interesse:</strong></p>\n<p>Chassis</p>\n<p>Carroceria</p>\n<p>Acabamento interno</p>\n<p>Acabamento externo</p><p></p><p>﻿<br></p>\n<p><br></p><p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:38 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=6
@@ -442,11 +442,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:53 GMT
+      - Tue, 30 Jul 2024 16:28:39 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '25324'
+      - '24427'
       Connection:
       - keep-alive
       Server:
@@ -467,8 +467,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=7","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=5","results":[{"id":1583520,"hash":"L68RRR5W","position_name":"BANCO DE TALENTOS - ESPECIALISTA DE DESENVOLVIMENTO DE PRODUTO","description":"<p><strong>Atividades:</strong></p>\n<p>Garantir a sinergia entre as soluções técnicas aplicadas nas diversas instalações do subsistema de sua responsabilidade. Deve levar em conta a robustez, o atendimento aos pré-requisitos (legislativos ou não), materiais, objetivos de performance, custo, massa, normas técnicas, planos de padronização, melhores práticas, lições aprendidas, dentre outras. Responsável pela divulgação e cumprimento da especificação dos componentes durante o desenvolvimento de novos produtos e também após. Deve ter um conhecimento aprofundado dos componentes e do subsistema sob sua responsabilidade bem como buscar uma constante atualização das últimas tecnologias aplicadas globalmente.</p>\n<p><strong>Necessário:</strong></p>\n<p>Formação em Engenharia</p>\n<p>Disponibilidade para viagem e trabalho presencial</p>\n<p>Inglês nível intermediário</p>\n<p>Experiência anterior no segmento automotivo</p>\n<p>Experiência anterior em processos de fabricação</p>\n<p><strong>Diferenciais: </strong></p>\n<p>Inglês nível avançado</p>\n<p>Pós-graduação e/ou Mestrado</p>\n<p><strong>Áreas de interesse:</strong></p>\n<p>Chassis</p>\n<p>Carroceria</p>\n<p>Acabamento interno</p>\n<p>Acabamento externo</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1583518,"hash":"L47666Y5","position_name":"Banco de talentos - Projetista cad de produto","description":"<p><strong>PROJETISTA CAD DE PRODUTO</strong></p>\n<p><strong>Atividades:</strong></p>\n<p>Execução de estudos de viabilidade, factibilidade de design, concepção de soluções técnicas, modelamentos complexos e suporte ao time de Engenharia do Produto utilizando ferramentas CAD. Aplicação dos conhecimentos em processos de fabricação na concepção das soluções técnicas. Avaliação das interfaces dos componentes sob sua responsabilidade com os demais subsistemas que compõe o veículo. Atuar de forma colaborativa com outros projetistas e demais entes do desenvolvimento do produto buscando o melhor compromisso entre performance e custo. </p>\n<p><strong>Necessário:</strong></p>\n<p>Formação de nível técnico mecânico ou eletromecânico</p>\n<p>Experiência anterior em CATIA ou NX</p>\n<p>Conhecimento em processos de fabricação</p>\n<p>Experiência anterior no segmento automotivo</p>\n<p><strong>Diferenciais: </strong></p>\n<p>Inglês nível intermediário ou acima</p>\n<p>Experiência anterior em outros softwares de CAD</p>\n<p>Formação em Engenharia</p>\n<p>Experiência anterior com ENOVIA PLM ou Team Center</p>\n<p><strong>Áreas de interesse:</strong></p>\n<p>Chassis</p>\n<p>Carroceria</p>\n<p>Acabamento interno</p>\n<p>Acabamento externo</p>\n<p>Packaging / DMU</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1956650,"hash":"QWYW45W6","position_name":"Business Developer/Manager (IT sector)","description":"<p><strong>Posição: Business Developer/Manager (IT sector)</strong></p>\n<p><strong>Localização: Oliveira de Azeméis, Aveiro (100% presencial)</strong></p>\n<p><br></p>\n<p><strong></strong>Estamos à procura de um(a) profissional dinâmico(a) e proativo(a) para assumir a responsabilidade por uma área de negócios de serviços em consultoria de TI. O(a) candidato(a) ideal será responsável pelo desempenho financeiro da sua unidade, bem como pela responsabilidade estratégica e comercial da mesma. Este papel é fundamental para o crescimento e sucesso da empresa.</p>\n<p><br></p>\n<p><strong>Sobre a nossa empresa:</strong></p>\n<p>A PTC Group é uma empresa de TI &amp; Engenharia fundada em 2006, com sede em Oliveira de Azeméis, Portugal.</p>\n<p>Presente em 14 países, com forte presença no Brasil, Portugal e Espanha, a PTC Group atua em cinco áreas de negócio: Estilo &amp; Design, TI, Indústria 4.0, Recrutamento &amp; Seleção e Formação.</p>\n<p>Especialistas em setores como Automóvel, TI, Aeronáutica, Energia, Espaço &amp; Defesa e Ferroviário &amp; Naval, a nossa missão é fornecer soluções de serviços ágeis e de alto desempenho, conectando os melhores talentos aos desafios de engenharia e tecnologia, com a visão de ser um dos melhores especialistas com alcance global.</p>\n<p>Os nossos valores fundamentais são: Simplicidade e Agilidade, Compromisso e Paixão, Energia Positiva, Colaboração e Transformação.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsabilidades e Tarefas</strong></p>\n<ul><li>Desempenho Financeiro: Monitorizar e gerir o desempenho financeiro da unidade de negócios, garantindo o cumprimento das metas e orçamentos estabelecidos.</li><li>Desenvolvimento Estratégico: Desenvolver e implementar estratégias de crescimento para a unidade de negócios, alinhadas com os objetivos gerais da empresa.</li><li>Identificação de Oportunidades de Mercado: Analisar tendências de mercado e identificar novas oportunidades de negócio no setor de TI e nas indústrias relacionadas.</li><li>Desenvolvimento de Relacionamentos: Estabelecer e manter relacionamentos sólidos com clientes potenciais, parceiros estratégicos e partes interessadas internas.</li><li>Gestão de Projetos: Coordenar propostas comerciais, definindo objetivos, prazos e recursos necessários para garantir a entrega de soluções de alta qualidade.</li><li>Negociação e Fechamento: Negociar termos comerciais e fechar contratos que sejam benéficos para todas as partes envolvidas.</li><li>Colaboração Interna: Trabalhar em estreita colaboração com as equipas internas para desenvolver soluções personalizadas que atendam às necessidades dos clientes.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos</strong></p>\n<ul><li>Licenciatura em Gestão, Engenharia ou similar.</li><li>Mínimo de 2 anos de experiência em desenvolvimento de negócios no setor de TI.</li><li>Excelentes capacidades de comunicação escrita e verbal em português e inglês.</li><li>Capacidade comprovada de identificar oportunidades e tomar iniciativas para desenvolvê-las.</li><li>Forte capacidade de negociação.</li><li>Experiência com P&amp;L.</li><li>Experiência com liderança de equipas de serviços.</li><li>Disponibilidade para viajar conforme necessário para reuniões com clientes e eventos.</li></ul>\n<p><br></p>\n<p>Se está pronto(a) para assumir um papel crucial no crescimento estratégico da nossa empresa e possui as qualificações necessárias, queremos conhecê-lo(a).﻿</p>","country":"Portugal","state":"","city":"Oliveira de Azeméis","address":"","zipcode":"","location_display":"Oliveira de Azeméis, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1786908,"hash":"L64XX33W","position_name":"Business Developer (Moldes e Injeção)","description":"<p><strong>Posição: Business Developer (Moldes e Injeção)</strong><br></p>\n<p><strong>Localização: Leiria</strong></p>\n<p></p>\n<p>O nosso cliente fabrica moldes de aço para injeção de plásticos técnicos e de alto desempenho, destacando-se pela precisão e repetibilidade em todos os componentes, baseando-se em mais de 30 anos de conhecimento e oferecendo um serviço técnico personalizado.</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li><strong><strong>﻿</strong></strong>Identificação e prospecção de novas oportunidades de negócios na indústria de moldes e injeção.</li><li>Desenvolvimento e implementação de estratégias comerciais para aumentar a quota de mercado.</li><li>Estabelecimento e manutenção de relacionamentos sólidos com clientes e parceiros.</li><li>Análise de mercado e monitorização da concorrência para identificar tendências e oportunidades.</li><li>Colaboração com as equipas de produção e engenharia para garantir a satisfação das necessidades dos clientes.</li><li>Participação em feiras, eventos e conferências do setor para promover a empresa e captar novos clientes.</li><li>Preparação de propostas comerciais e negociações de contratos.</li><li>Acompanhamento do desempenho das vendas e elaboração de relatórios de progresso.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<ul><li><strong><strong>﻿</strong></strong>Licenciatura em Gestão, Engenharia, Marketing ou área relacionada.</li><li>Experiência mínima de 3 anos na área de desenvolvimento de negócios, preferencialmente na indústria de moldes e injeção.</li><li>Conhecimento técnico sobre processos de moldagem e injeção.</li><li>Excelente capacidade de comunicação e negociação.</li><li>Perfil dinâmico, proativo e orientado para resultados.</li><li>Facilidade em trabalhar de forma independente e em equipa.</li><li>Disponibilidade para viajar.</li><li>Bons conhecimentos de Inglês, falado e escrito; conhecimentos de outras línguas serão valorizados.</li></ul>","country":"Portugal","state":"Leiria District","city":"Leiria","address":"","zipcode":"","location_display":"Leiria, Leiria District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718310,"hash":"L8RVV98R","position_name":"Calibration in Tatui","description":"<p>Engenheiro senior, com mais de 5 anos de experiência em&nbsp;calibração de motores em cliclo Otto, com inglês fluente, presencial em Tatui-SP.</p>","country":"Brazil","state":"SP","city":"Tatuí","address":"","zipcode":"","location_display":"Tatuí, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1925200,"hash":"LR4X5Y9R","position_name":"CAMI Integrador Centros de Maquinação (CNC)","description":"<p><strong>Título do </strong><strong>Cargo: Encarregado de Equipamentos (CAMI) Integrador Centros de Maquinação</strong></p>\n<p><strong>Localização</strong>: Aveiro, Portugal</p>\n<p><strong>Descrição da Empresa</strong>: O nosso cliente é uma renomada empresa no setor automotivo, reconhecida pela inovação e excelência na montagem de componentes para veículos.</p>\n<p></p>\n<p><strong>Âmbito do projeto</strong>: Projeto de montagem e maquinação de componentes de motor elétrico, para veículo híbrido.</p>\n<p></p>\n<p><strong>Requisitos:</strong></p>\n<p>Experiência em industrialização de peças em Centros de Maquinação Horizontais 4 Eixos Paletizados:</p>\n<ul><li>Validação de ferramentas de corte.</li><li>Validação de montagens aperto peça.</li><li>Realização de programas CNC Siemens 840 (ISO); código G.</li><li>Centramento do processo de maquinação.</li><li>Realização de capabilidades.</li><li>Anos de experiência: idealmente entre 5 a 10 anos (moldes, automotivo, etc.).</li><li>Pode ter curso superior (engenharia mecânica) ou curso técnico-profissional.</li><li>Pessoa com capacidade de resiliência e comunicação, para funções de chão de fábrica, pilotagem e contacto com empresas exteriores.</li><li>Idiomas: fluência obrigatória em português; inglês intermédio obrigatório; francês será valorizado.</li></ul>\n<p>﻿﻿</p>\n<p><strong>Missão:</strong></p>\n<ul><li>Assegurar a aplicação das normas de construção e segurança do meio.</li><li>Privilegiar as boas relações técnicas com os fornecedores no seu perímetro de responsabilidade.</li><li>Assegurar a boa receção física e integração dos meios.</li><li>Garantir que os meios comprados atingem as performances definidas.</li><li>Participar nas reuniões Qualidade/Processos.</li></ul>\n<p></p>\n<p><strong>Atividades:</strong></p>\n<ul><li>Formalizar os Caderno de Encargos técnicos e organizar as propostas técnicas com a Direção de Compras,</li><li>Analisar a pertinência técnicas das propostas em colaboração com os Especialistas da Tecnologia do processo em causa.</li><li>Dar assistência à Direção de Compras para a negociação comercial.</li><li>Definir as etapas do projeto, o seu processo de obtenção da qualidade assim como o seu plano de validação.</li><li>Recensear, analisar e formalizar todos os elementos necessitando de um acordo e/ou uma auditoria.</li><li>Pilotar a integração dos meios na linha.</li><li>Assegurar o foco, o arranque e depuração dos meios de produção.</li><li>Assegurar a integração de um produto num processo industrial contemplando máquina/aperto peça/ferramentas.</li><li>Definir o plano de acompanhamento para o conjunto dos meios de processo e fabricação dos meios em causa (aprendizagem, formações).</li></ul>","country":"Portugal","state":"","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1831957,"hash":"L76VVXRX","position_name":"Casting Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Casting Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in casting process in the automotive sector</li><li>Experience with&nbsp;High Pressure Aluminium casting is a plus﻿</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Pitești","address":"","zipcode":"","location_display":"Pitești, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1831960,"hash":"LR4RRY8R","position_name":"Casting Process Engineer (CP)","description":"<p><strong>Job Title: <strong>Casting Process Engineer (CP)</strong>﻿</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p><strong>Company Description</strong>: Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p><strong><br></strong></p>\n<p><strong>﻿Mission:</strong></p>\n<ul><li>To be responsible for the definition and evolution of a part process by piloting the design, realization and integration of a new production line or modifications to an existing line, always taking into account a product/process approach and QCD objectives.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Designing the reference range for a family of parts and breaking it down into operating ranges to achieve the Quality, Performance and Cost objectives of the projects in question.</li><li>Depending on the Metier, Project or Series Life perimeter, follow the different Industrialization phases of the parts as well as those of the organs with the BE, projects and manufacturing.</li><li>Establish and maintain a range of diversity on the line.</li><li>Define the functional characteristics in the plans of the blanks, as well as the POE of a line.</li><li>Designing the monitoring plan for the manufacture and assembly of parts.</li><li>Ensuring the coherence of a part's process in the industrial system world.</li></ul>\n<p>﻿<strong><br></strong></p>\n<p><strong>﻿﻿Requirements:</strong><br></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>﻿﻿Higher education: Mechanical Engineering, Electrical Engineering or similar</li><li>Professional experience in an industrial environment: junior or intermediate, between 3 and 5 years</li><li>Experience in casting processes in the automotive sector</li><li>Experience with High Pressure Aluminium casting is a plus﻿</li></ul>","country":"Romania","state":"AG","city":"Pitești","address":"","zipcode":"","location_display":"Pitești, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1945202,"hash":"QWYVVR46","position_name":"Chefe Secção Bancada","description":"<p>O nosso cliente fabrica moldes de aço para injeção de plásticos técnicos e de alto desempenho, destacando-se pela precisão e repetibilidade em todos os componentes, baseando-se em mais de 30 anos de conhecimento e oferecendo um serviço técnico personalizado.</p>\n<p>Atualmente encontram-se a recrutar um <strong>Chefe de Bancada</strong></p>\n<p><strong>Requisitos do Candidato:</strong></p>\n<ul><li>Licenciatura em Engenharia de Moldes, Mecânica ou Gestão Industrial (preferencial);</li><li>Mínimo de 5 anos de experiência em funções semelhantes (preferencial);</li><li>Excelentes conhecimentos de Injeção plásticas e/ou moldes</li><li>Conhecimentos das normas relacionadas com a área de injeção de plásticos;</li><li>Fluência em inglês;</li><li>Excelente capacidade de liderança e organização;</li><li>Forte orientação para resultados.</li></ul>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>:<br></strong></p>\n<ul><li><strong></strong>Coordenar a secção e gestão do trabalho;´</li><li>\n<p>Participar na definição do processo de fabrico dos moldes;</p></li><li>Assegurar o acompanhamento da execução das alterações e correções;</li><li>Auxiliar a secção de planeamento na atualização do Planeamento Geral do Molde;</li><li>Fazer cumprir todas as especificações do sistema de gestão;</li><li>Participar na identificação das necessidades de formação dos colaboradores;</li><li>Colaborar no acompanhamento/integração de novos(as) colaboradores(as);</li><li>Colaborar no estabelecimento de ações decorrentes de auditorias ao sistema de gestão;</li><li>Assegurar-se de que os equipamentos de proteção individual são usados coerentemente pelos seus colaboradores;</li><li>Assegurar a preservação e funcionamento dos equipamentos da sua secção;</li><li>Verificar se os(as) seus/suas colaboradores(as) estão a tomar as medidas preventivas;</li><li>Participar no processo de avaliação de fornecedores;</li><li>Definir horas extraordinárias, férias, etc. tendo em conta as diretrizes da Direção Produção;</li><li>Participar na identificação de perigos e avaliação dos riscos do seu sector;</li><li>Dinamizar as atividades previstas no PEI para o seu sector;</li><li>Utilizar corretamente máquinas, aparelhos, instrumentos, ferramentas, substâncias perigosas e outros equipamentos</li><li>Zelar pela sua segurança e saúde bem como pela segurança e saúde das outras pessoas que possam ser afetadas pelas suas&nbsp;ações ou omissões no trabalho;</li><li>Cumprir as prescrições de segurança, higiene e saúde no trabalho estabelecidas nas disposições legais ou outras aplicáveis,&nbsp;assim como as instruções determinadas pela empresa;</li><li>Colaborar na melhoria da qualidade, ambiente e segurança sugerindo melhorias;</li><li>Comunicar imediatamente à chefia direta ou ao/à responsável de SST as avarias e deficiências detetadas que se lhe afigurem possam originar perigo grave e iminente, assim como qualquer deficiência nos sistemas de proteção;</li><li>Autoridade para se afastar de situações de trabalho que considerem constituir um perigo grave e iminente para a sua vida ou&nbsp;saúde, bem como mecanismos para os proteger de consequências indevidas ao fazê-lo;</li><li>Comparecer, quando convocado(a), aos exames médicos/consultas da medicina do trabalho;</li><li>Colaborar nas ações de prevenção e intervir em emergência de acordo com os procedimentos definidos.</li></ul>","country":"Portugal","state":"","city":"Leiria","address":"","zipcode":"","location_display":"Leiria, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1843527,"hash":"QX34XXYY","position_name":"Cientista de Dados / Engenheiro de ML","description":"<p><strong>Papéis </strong><strong>e Responsabilidades</strong></p>\n<ul>\n <li>Trabalhar      com parceiros de negócios, engenheiros de dados e times de tecnologia para      desenvolvimento de soluções internas</li>\n <li>Atuar      como representante de Advanced Anaytics e GenAI em projetos estratégicos      das áreas corporativas e industriais</li>\n</ul>\n<ul><li>Construir modelos de aprendizado de máquina e estatísticos para prever resultados futuros. </li><li>Explorar e construir casos de uso relacionados a aplicações de IA Generativa, colaborando para a construção de uma estratégia corporativa.</li></ul>\n<ul>\n <li>Realizar análises exploratórias de      dados para descobrir padrões e tendências, validar hipóteses e gerar      insights de negócio;</li>\n <li>Implementar,      testar, fazer deploy, documentar e depurar pipeline de dados e de machine      learning (MlOps);</li>\n <li>Evoluir      o roadmap tecnológico pesquisando e acompanhando a evolução das      tecnologias e mercados;</li>\n</ul>\n<p><strong>Qualificações Essenciais</strong></p>\n<ul>\n <li>Ensino      superior completo nas áreas de Ciência da Computação, Engenharias,      Sistemas de Informação, ou áreas correlatas;</li>\n <li>Pelo      menos 3 anos de experiência relevante como cientista de dados/engenheiro      de machine learning;</li>\n <li>Experiência      na plataforma de dados Databricks para construção e administração dos      modelos;</li>\n <li>Experiência      com linguagem de programação Python, SQL;</li>\n <li>Experiência      com o processo de ciência de dados, entendimento do problema,      levantamentos de hipóteses, análise exploratória de dados, preparação dos      dados, desenvolvimento de modelos preditivos e implantação;</li>\n <li>Experiência      em técnicas de Machine Learning (Classificação, Regressão) e      ferramentas/bibliotecas Open Source (SciKit Learn, Keras, ou correlatos);</li>\n <li>Experiência      com deploy de modelos em nuvem, construção de feature store, serving,      MlOps (Azure, Databricks, Docker e Mlflow)</li>\n <li>Conhecimento      no desenvolvimento de aplicações utilizando GenAI/LLM (Databricks / Azure      AI Studio)</li>\n</ul>\n<p><strong>Diferencial:</strong></p>\n<ul>\n <li>Proatividade,      senso de dono e grande desejo de aprender e evoluir com a gente!</li>\n <li>Experiência      em desenvolvimento de aplicações de GenAI/LLM</li>\n <li>Experiência      anterior no setor industrial, mineração ou metalúrgico.</li>\n <li>Conhecimento      em Deep Learning</li>\n <li>Conhecimento      em modelos de series temporais</li>\n <li>Conhecimento      em Otimização de sistemas</li>\n <li>Conhecimento      em tecnologias de IoT (MQTT, LoRa, OPCUA)</li>\n <li>Certificações      Microsoft DP100, Databricks Machine Learning Associate, e correlatas</li>\n <li>Espanhol</li>\n</ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:53 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=7","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=5","results":[{"id":1583520,"hash":"L68RRR5W","position_name":"BANCO DE TALENTOS - ESPECIALISTA DE DESENVOLVIMENTO DE PRODUTO","description":"<p><strong>Atividades:</strong></p>\n<p>Garantir a sinergia entre as soluções técnicas aplicadas nas diversas instalações do subsistema de sua responsabilidade. Deve levar em conta a robustez, o atendimento aos pré-requisitos (legislativos ou não), materiais, objetivos de performance, custo, massa, normas técnicas, planos de padronização, melhores práticas, lições aprendidas, dentre outras. Responsável pela divulgação e cumprimento da especificação dos componentes durante o desenvolvimento de novos produtos e também após. Deve ter um conhecimento aprofundado dos componentes e do subsistema sob sua responsabilidade bem como buscar uma constante atualização das últimas tecnologias aplicadas globalmente.</p>\n<p><strong>Necessário:</strong></p>\n<p>Formação em Engenharia</p>\n<p>Disponibilidade para viagem e trabalho presencial</p>\n<p>Inglês nível intermediário</p>\n<p>Experiência anterior no segmento automotivo</p>\n<p>Experiência anterior em processos de fabricação</p>\n<p><strong>Diferenciais: </strong></p>\n<p>Inglês nível avançado</p>\n<p>Pós-graduação e/ou Mestrado</p>\n<p><strong>Áreas de interesse:</strong></p>\n<p>Chassis</p>\n<p>Carroceria</p>\n<p>Acabamento interno</p>\n<p>Acabamento externo</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1583518,"hash":"L47666Y5","position_name":"Banco de talentos - Projetista cad de produto","description":"<p><strong>PROJETISTA CAD DE PRODUTO</strong></p>\n<p><strong>Atividades:</strong></p>\n<p>Execução de estudos de viabilidade, factibilidade de design, concepção de soluções técnicas, modelamentos complexos e suporte ao time de Engenharia do Produto utilizando ferramentas CAD. Aplicação dos conhecimentos em processos de fabricação na concepção das soluções técnicas. Avaliação das interfaces dos componentes sob sua responsabilidade com os demais subsistemas que compõe o veículo. Atuar de forma colaborativa com outros projetistas e demais entes do desenvolvimento do produto buscando o melhor compromisso entre performance e custo. </p>\n<p><strong>Necessário:</strong></p>\n<p>Formação de nível técnico mecânico ou eletromecânico</p>\n<p>Experiência anterior em CATIA ou NX</p>\n<p>Conhecimento em processos de fabricação</p>\n<p>Experiência anterior no segmento automotivo</p>\n<p><strong>Diferenciais: </strong></p>\n<p>Inglês nível intermediário ou acima</p>\n<p>Experiência anterior em outros softwares de CAD</p>\n<p>Formação em Engenharia</p>\n<p>Experiência anterior com ENOVIA PLM ou Team Center</p>\n<p><strong>Áreas de interesse:</strong></p>\n<p>Chassis</p>\n<p>Carroceria</p>\n<p>Acabamento interno</p>\n<p>Acabamento externo</p>\n<p>Packaging / DMU</p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1956650,"hash":"QWYW45W6","position_name":"Business Developer/Manager (IT sector)","description":"<p><strong>Posição: Business Developer/Manager (IT sector)</strong></p>\n<p><strong>Localização: Oliveira de Azeméis, Aveiro (100% presencial)</strong></p>\n<p><br></p>\n<p><strong></strong>Estamos à procura de um(a) profissional dinâmico(a) e proativo(a) para assumir a responsabilidade por uma área de negócios de serviços em consultoria de TI. O(a) candidato(a) ideal será responsável pelo desempenho financeiro da sua unidade, bem como pela responsabilidade estratégica e comercial da mesma. Este papel é fundamental para o crescimento e sucesso da empresa.</p>\n<p><br></p>\n<p><strong>Sobre a nossa empresa:</strong></p>\n<p>A PTC Group é uma empresa de TI &amp; Engenharia fundada em 2006, com sede em Oliveira de Azeméis, Portugal.</p>\n<p>Presente em 14 países, com forte presença no Brasil, Portugal e Espanha, a PTC Group atua em cinco áreas de negócio: Estilo &amp; Design, TI, Indústria 4.0, Recrutamento &amp; Seleção e Formação.</p>\n<p>Especialistas em setores como Automóvel, TI, Aeronáutica, Energia, Espaço &amp; Defesa e Ferroviário &amp; Naval, a nossa missão é fornecer soluções de serviços ágeis e de alto desempenho, conectando os melhores talentos aos desafios de engenharia e tecnologia, com a visão de ser um dos melhores especialistas com alcance global.</p>\n<p>Os nossos valores fundamentais são: Simplicidade e Agilidade, Compromisso e Paixão, Energia Positiva, Colaboração e Transformação.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsabilidades e Tarefas</strong></p>\n<ul><li>Desempenho Financeiro: Monitorizar e gerir o desempenho financeiro da unidade de negócios, garantindo o cumprimento das metas e orçamentos estabelecidos.</li><li>Desenvolvimento Estratégico: Desenvolver e implementar estratégias de crescimento para a unidade de negócios, alinhadas com os objetivos gerais da empresa.</li><li>Identificação de Oportunidades de Mercado: Analisar tendências de mercado e identificar novas oportunidades de negócio no setor de TI e nas indústrias relacionadas.</li><li>Desenvolvimento de Relacionamentos: Estabelecer e manter relacionamentos sólidos com clientes potenciais, parceiros estratégicos e partes interessadas internas.</li><li>Gestão de Projetos: Coordenar propostas comerciais, definindo objetivos, prazos e recursos necessários para garantir a entrega de soluções de alta qualidade.</li><li>Negociação e Fechamento: Negociar termos comerciais e fechar contratos que sejam benéficos para todas as partes envolvidas.</li><li>Colaboração Interna: Trabalhar em estreita colaboração com as equipas internas para desenvolver soluções personalizadas que atendam às necessidades dos clientes.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos</strong></p>\n<ul><li>Licenciatura em Gestão, Engenharia ou similar.</li><li>Mínimo de 2 anos de experiência em desenvolvimento de negócios no setor de TI.</li><li>Excelentes capacidades de comunicação escrita e verbal em português e inglês.</li><li>Capacidade comprovada de identificar oportunidades e tomar iniciativas para desenvolvê-las.</li><li>Forte capacidade de negociação.</li><li>Experiência com P&amp;L.</li><li>Experiência com liderança de equipas de serviços.</li><li>Disponibilidade para viajar conforme necessário para reuniões com clientes e eventos.</li></ul>\n<p><br></p>\n<p>Se está pronto(a) para assumir um papel crucial no crescimento estratégico da nossa empresa e possui as qualificações necessárias, queremos conhecê-lo(a).﻿</p>","country":"Portugal","state":"","city":"Oliveira de Azeméis","address":"","zipcode":"","location_display":"Oliveira de Azeméis, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1966689,"hash":"L3944W7V","position_name":"Business Support (Energy Sector)","description":"<p>A PTC Group está a recrutar um Business Support para reforçar a nossa equipa, em regime remoto ou presencial.<br></p>\n<p>Este Business Support serão responsáveis por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Elaborar relatórios de apoio operacional com KPIs, SLAs e apresentações dos mesmos aos clientes internos e externos.</li><li>Elaboração de análises financeiras e custos para cada projecto.</li><li>Realizar o levantamento de requisitos para melhoria contínua dos processos organizacionais de documentação e&nbsp;contratuais.</li><li>Gerir os contratos estabelecidos,&nbsp;assegurando o cumprimento dos termos acordados com fornecedores, clientes e outros parceiros.</li><li>Elaborar cadernos de encargos e seguir o processo de lançamento de consultas e concursos.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Gestão, Economia ou similares.</li><li>Experiência mínima de +3 anos em funções similares (gestão de contratos).</li><li>Experiência em metodologias de Gestão de Projetos (Scrum) (nice-to-have).</li><li>Experiência em ferramentas do Microsoft 365 (Excel, Word, PowerPoint)</li><li>Experiência anterior com gestão contratos&nbsp;no sector energético (nice-to-have)</li></ul><p></p>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718310,"hash":"L8RVV98R","position_name":"Calibration in Tatui","description":"<p>Engenheiro senior, com mais de 5 anos de experiência em&nbsp;calibração de motores em cliclo Otto, com inglês fluente, presencial em Tatui-SP.</p>","country":"Brazil","state":"SP","city":"Tatuí","address":"","zipcode":"","location_display":"Tatuí, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1925200,"hash":"LR4X5Y9R","position_name":"CAMI Integrador Centros de Maquinação (CNC)","description":"<p><strong>Título do </strong><strong>Cargo: Encarregado de Equipamentos (CAMI) Integrador Centros de Maquinação</strong></p>\n<p><strong>Localização</strong>: Aveiro, Portugal</p>\n<p><strong>Descrição da Empresa</strong>: O nosso cliente é uma renomada empresa no setor automotivo, reconhecida pela inovação e excelência na montagem de componentes para veículos.</p>\n<p></p>\n<p><strong>Âmbito do projeto</strong>: Projeto de montagem e maquinação de componentes de motor elétrico, para veículo híbrido.</p>\n<p></p>\n<p><strong>Requisitos:</strong></p>\n<p>Experiência em industrialização de peças em Centros de Maquinação Horizontais 4 Eixos Paletizados:</p>\n<ul><li>Validação de ferramentas de corte.</li><li>Validação de montagens aperto peça.</li><li>Realização de programas CNC Siemens 840 (ISO); código G.</li><li>Centramento do processo de maquinação.</li><li>Realização de capabilidades.</li><li>Anos de experiência: idealmente entre 5 a 10 anos (moldes, automotivo, etc.).</li><li>Pode ter curso superior (engenharia mecânica) ou curso técnico-profissional.</li><li>Pessoa com capacidade de resiliência e comunicação, para funções de chão de fábrica, pilotagem e contacto com empresas exteriores.</li><li>Idiomas: fluência obrigatória em português; inglês intermédio obrigatório; francês será valorizado.</li></ul>\n<p>﻿﻿</p>\n<p><strong>Missão:</strong></p>\n<ul><li>Assegurar a aplicação das normas de construção e segurança do meio.</li><li>Privilegiar as boas relações técnicas com os fornecedores no seu perímetro de responsabilidade.</li><li>Assegurar a boa receção física e integração dos meios.</li><li>Garantir que os meios comprados atingem as performances definidas.</li><li>Participar nas reuniões Qualidade/Processos.</li></ul>\n<p></p>\n<p><strong>Atividades:</strong></p>\n<ul><li>Formalizar os Caderno de Encargos técnicos e organizar as propostas técnicas com a Direção de Compras,</li><li>Analisar a pertinência técnicas das propostas em colaboração com os Especialistas da Tecnologia do processo em causa.</li><li>Dar assistência à Direção de Compras para a negociação comercial.</li><li>Definir as etapas do projeto, o seu processo de obtenção da qualidade assim como o seu plano de validação.</li><li>Recensear, analisar e formalizar todos os elementos necessitando de um acordo e/ou uma auditoria.</li><li>Pilotar a integração dos meios na linha.</li><li>Assegurar o foco, o arranque e depuração dos meios de produção.</li><li>Assegurar a integração de um produto num processo industrial contemplando máquina/aperto peça/ferramentas.</li><li>Definir o plano de acompanhamento para o conjunto dos meios de processo e fabricação dos meios em causa (aprendizagem, formações).</li></ul>","country":"Portugal","state":"","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1831957,"hash":"L76VVXRX","position_name":"Casting Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Casting Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in casting process in the automotive sector</li><li>Experience with&nbsp;High Pressure Aluminium casting is a plus﻿</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Pitești","address":"","zipcode":"","location_display":"Pitești, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1831960,"hash":"LR4RRY8R","position_name":"Casting Process Engineer (CP)","description":"<p><strong>Job Title: <strong>Casting Process Engineer (CP)</strong>﻿</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p><strong>Company Description</strong>: Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p><strong><br></strong></p>\n<p><strong>﻿Mission:</strong></p>\n<ul><li>To be responsible for the definition and evolution of a part process by piloting the design, realization and integration of a new production line or modifications to an existing line, always taking into account a product/process approach and QCD objectives.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Designing the reference range for a family of parts and breaking it down into operating ranges to achieve the Quality, Performance and Cost objectives of the projects in question.</li><li>Depending on the Metier, Project or Series Life perimeter, follow the different Industrialization phases of the parts as well as those of the organs with the BE, projects and manufacturing.</li><li>Establish and maintain a range of diversity on the line.</li><li>Define the functional characteristics in the plans of the blanks, as well as the POE of a line.</li><li>Designing the monitoring plan for the manufacture and assembly of parts.</li><li>Ensuring the coherence of a part's process in the industrial system world.</li></ul>\n<p>﻿<strong><br></strong></p>\n<p><strong>﻿﻿Requirements:</strong><br></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>﻿﻿Higher education: Mechanical Engineering, Electrical Engineering or similar</li><li>Professional experience in an industrial environment: junior or intermediate, between 3 and 5 years</li><li>Experience in casting processes in the automotive sector</li><li>Experience with High Pressure Aluminium casting is a plus﻿</li></ul>","country":"Romania","state":"AG","city":"Pitești","address":"","zipcode":"","location_display":"Pitești, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1945202,"hash":"QWYVVR46","position_name":"Chefe Secção Bancada","description":"<p>O nosso cliente fabrica moldes de aço para injeção de plásticos técnicos e de alto desempenho, destacando-se pela precisão e repetibilidade em todos os componentes, baseando-se em mais de 30 anos de conhecimento e oferecendo um serviço técnico personalizado.</p>\n<p>Atualmente encontram-se a recrutar um <strong>Chefe de Bancada</strong></p>\n<p><strong>Requisitos do Candidato:</strong></p>\n<ul><li>Licenciatura em Engenharia de Moldes, Mecânica ou Gestão Industrial (preferencial);</li><li>Mínimo de 5 anos de experiência em funções semelhantes (preferencial);</li><li>Excelentes conhecimentos de Injeção plásticas e/ou moldes</li><li>Conhecimentos das normas relacionadas com a área de injeção de plásticos;</li><li>Fluência em inglês;</li><li>Excelente capacidade de liderança e organização;</li><li>Forte orientação para resultados.</li></ul>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>:<br></strong></p>\n<ul><li><strong></strong>Coordenar a secção e gestão do trabalho;´</li><li>\n<p>Participar na definição do processo de fabrico dos moldes;</p></li><li>Assegurar o acompanhamento da execução das alterações e correções;</li><li>Auxiliar a secção de planeamento na atualização do Planeamento Geral do Molde;</li><li>Fazer cumprir todas as especificações do sistema de gestão;</li><li>Participar na identificação das necessidades de formação dos colaboradores;</li><li>Colaborar no acompanhamento/integração de novos(as) colaboradores(as);</li><li>Colaborar no estabelecimento de ações decorrentes de auditorias ao sistema de gestão;</li><li>Assegurar-se de que os equipamentos de proteção individual são usados coerentemente pelos seus colaboradores;</li><li>Assegurar a preservação e funcionamento dos equipamentos da sua secção;</li><li>Verificar se os(as) seus/suas colaboradores(as) estão a tomar as medidas preventivas;</li><li>Participar no processo de avaliação de fornecedores;</li><li>Definir horas extraordinárias, férias, etc. tendo em conta as diretrizes da Direção Produção;</li><li>Participar na identificação de perigos e avaliação dos riscos do seu sector;</li><li>Dinamizar as atividades previstas no PEI para o seu sector;</li><li>Utilizar corretamente máquinas, aparelhos, instrumentos, ferramentas, substâncias perigosas e outros equipamentos</li><li>Zelar pela sua segurança e saúde bem como pela segurança e saúde das outras pessoas que possam ser afetadas pelas suas&nbsp;ações ou omissões no trabalho;</li><li>Cumprir as prescrições de segurança, higiene e saúde no trabalho estabelecidas nas disposições legais ou outras aplicáveis,&nbsp;assim como as instruções determinadas pela empresa;</li><li>Colaborar na melhoria da qualidade, ambiente e segurança sugerindo melhorias;</li><li>Comunicar imediatamente à chefia direta ou ao/à responsável de SST as avarias e deficiências detetadas que se lhe afigurem possam originar perigo grave e iminente, assim como qualquer deficiência nos sistemas de proteção;</li><li>Autoridade para se afastar de situações de trabalho que considerem constituir um perigo grave e iminente para a sua vida ou&nbsp;saúde, bem como mecanismos para os proteger de consequências indevidas ao fazê-lo;</li><li>Comparecer, quando convocado(a), aos exames médicos/consultas da medicina do trabalho;</li><li>Colaborar nas ações de prevenção e intervir em emergência de acordo com os procedimentos definidos.</li></ul>","country":"Portugal","state":"","city":"Leiria","address":"","zipcode":"","location_display":"Leiria, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1843527,"hash":"QX34XXYY","position_name":"Cientista de Dados / Engenheiro de ML","description":"<p><strong>Papéis </strong><strong>e Responsabilidades</strong></p>\n<ul>\n <li>Trabalhar      com parceiros de negócios, engenheiros de dados e times de tecnologia para      desenvolvimento de soluções internas</li>\n <li>Atuar      como representante de Advanced Anaytics e GenAI em projetos estratégicos      das áreas corporativas e industriais</li>\n</ul>\n<ul><li>Construir modelos de aprendizado de máquina e estatísticos para prever resultados futuros. </li><li>Explorar e construir casos de uso relacionados a aplicações de IA Generativa, colaborando para a construção de uma estratégia corporativa.</li></ul>\n<ul>\n <li>Realizar análises exploratórias de      dados para descobrir padrões e tendências, validar hipóteses e gerar      insights de negócio;</li>\n <li>Implementar,      testar, fazer deploy, documentar e depurar pipeline de dados e de machine      learning (MlOps);</li>\n <li>Evoluir      o roadmap tecnológico pesquisando e acompanhando a evolução das      tecnologias e mercados;</li>\n</ul>\n<p><strong>Qualificações Essenciais</strong></p>\n<ul>\n <li>Ensino      superior completo nas áreas de Ciência da Computação, Engenharias,      Sistemas de Informação, ou áreas correlatas;</li>\n <li>Pelo      menos 3 anos de experiência relevante como cientista de dados/engenheiro      de machine learning;</li>\n <li>Experiência      na plataforma de dados Databricks para construção e administração dos      modelos;</li>\n <li>Experiência      com linguagem de programação Python, SQL;</li>\n <li>Experiência      com o processo de ciência de dados, entendimento do problema,      levantamentos de hipóteses, análise exploratória de dados, preparação dos      dados, desenvolvimento de modelos preditivos e implantação;</li>\n <li>Experiência      em técnicas de Machine Learning (Classificação, Regressão) e      ferramentas/bibliotecas Open Source (SciKit Learn, Keras, ou correlatos);</li>\n <li>Experiência      com deploy de modelos em nuvem, construção de feature store, serving,      MlOps (Azure, Databricks, Docker e Mlflow)</li>\n <li>Conhecimento      no desenvolvimento de aplicações utilizando GenAI/LLM (Databricks / Azure      AI Studio)</li>\n</ul>\n<p><strong>Diferencial:</strong></p>\n<ul>\n <li>Proatividade,      senso de dono e grande desejo de aprender e evoluir com a gente!</li>\n <li>Experiência      em desenvolvimento de aplicações de GenAI/LLM</li>\n <li>Experiência      anterior no setor industrial, mineração ou metalúrgico.</li>\n <li>Conhecimento      em Deep Learning</li>\n <li>Conhecimento      em modelos de series temporais</li>\n <li>Conhecimento      em Otimização de sistemas</li>\n <li>Conhecimento      em tecnologias de IoT (MQTT, LoRa, OPCUA)</li>\n <li>Certificações      Microsoft DP100, Databricks Machine Learning Associate, e correlatas</li>\n <li>Espanhol</li>\n</ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:39 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=7
@@ -488,11 +488,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:54 GMT
+      - Tue, 30 Jul 2024 16:28:39 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '29509'
+      - '29784'
       Connection:
       - keep-alive
       Server:
@@ -513,8 +513,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=8","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=6","results":[{"id":1842489,"hash":"L393465V","position_name":"Commercial Director","description":"<p>Nos encontramos en la búsqueda de un <strong>Director/a Comercial</strong> para el territorio Español, para una compañía&nbsp;﻿líder&nbsp;de protección contra incendios en España. Actualmente cuenta con&nbsp;más de 150 profesionales, más de 25.000 clientes, y se encuentran&nbsp;en pleno proceso de expansión.&nbsp;</p>\n<p><strong>Responsabilidades:</strong><br></p>\n<ul><li><strong>Dirección del Equipo Comercial:</strong> Liderar y dirigir el equipo de ventas en España, estableciendo objetivos, monitoreando el rendimiento y proporcionando mentoría y apoyo continuo.</li><li><strong>Gestión de Cuentas Clave:</strong> Gestionar personalmente las cuentas más grandes y estratégicas, asegurando un alto nivel de satisfacción del cliente y oportunidades de ventas recurrentes.</li><li><strong>Crecimiento Orgánico:</strong> Lograr un crecimiento orgánico de al menos un 10% en los servicios de mantenimiento, identificando y aprovechando oportunidades de mercado y optimizando las estrategias de ventas.</li><li><strong>Estructuración de Procesos de Ventas:</strong> Desarrollar y optimizar la estructura del equipo de ventas, incluyendo la implementación de procesos y herramientas eficaces para maximizar el rendimiento y la eficiencia.</li><li><strong>Gestión de Presupuestos y Ofertas:</strong> Supervisar la creación y aprobación de presupuestos y ofertas, asegurando la rentabilidad deseada por la empresa.</li><li><strong>Atención al Cliente:</strong> Proporcionar soporte y resolución de problemas para clientes clave, manteniendo una comunicación fluida y eficaz.</li><li><strong>Administración de Contratos:</strong> Coordinar la redacción, revisión y firma de contratos, asegurando el cumplimiento de plazos y términos.</li><li><strong>Reportes y Análisis:</strong> Preparar informes de ventas, analizar datos para identificar oportunidades de mejora y áreas de crecimiento.</li></ul>\n<p><strong>Requisitos:</strong></p>\n<ul><li>Experiencia sólida en gestión de equipos comerciales y ventas; teniendo un historial de éxito en protección contra incendios (PCI) o sectores similares (e.g., ascensores, HVAC, facility management, etc.).</li><li>Habilidad para gestionar grandes cuentas y mantener relaciones sólidas con los clientes.</li><li>Excelentes habilidades de liderazgo, comunicación y resolución de problemas.</li><li>Habilidad numérica y competencia en el uso de sistemas CRM y otras herramientas de ventas.</li><li>Disponibilidad para desplazarse regularmente dentro de España según las necesidades del negocio.</li></ul>\n<p><br></p><p>- ﻿Hor<span style=\"font-family: inherit; font-size: 0.875rem;\">ario: Jornada completa</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">- Incorporación: Septiembre 2024</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">- Contrato indefinido</span></p><p>- Lugar de trabajo: alguna de las sedes en Barcelona (Gavà, Rubí, o Granollers)</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">- Disponibilidad para viajar por toda España para visitar clientes o las diferentes sedes</span><br></p><p>operativas</p>\n<p><br></p>\n<p><strong>Si cumples con estos requisitos y estás interesado/a en unirte al equipo, te invitamos a postularte para esta emocionante oportunidad. ¡Esperamos recibir tu candidatura!﻿</strong></p>","country":"Spain","state":"CT","city":"Barcelona","address":"","zipcode":"","location_display":"Barcelona, CT, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1834624,"hash":"LR4R9X9R","position_name":"Consultor de Gestão","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"291\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"292\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"293\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"294\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"295\"><font _mstmutation=\"1\" _msttexthash=\"17856410\" _msthash=\"401\">Atuar junto aos distribuidores nos processos de Gestão de Vendas, atuando para o alcance das metas de volume de vendas, TPV (faturamento de cartão de crédito) e NPS dos distribuidores;</font><br><font _mstmutation=\"1\" _msttexthash=\"1912326\" _msthash=\"402\">Realizar análises de mercado e gestão de indicadores;</font><br><font _mstmutation=\"1\" _msttexthash=\"1155908\" _msthash=\"403\">Realiza a gestão da carteira de clientes;</font><br><font _mstmutation=\"1\" _msttexthash=\"7887867\" _msthash=\"404\">Capacitar as equipes de vendas nos processos de gestão de vendas, sistemas Vendas Rede Moura e procedimentos de vendas;</font><br><font _mstmutation=\"1\" _msttexthash=\"2015195\" _msthash=\"405\">Promover o Sistema Moura de Gestão nas equipes de Vendas;</font><br><font _mstmutation=\"1\" _msttexthash=\"4059653\" _msthash=\"406\">Suportar o distribuidor na construção e execução de Planos de Ação e Anomalias;</font><br><font _mstmutation=\"1\" _msttexthash=\"4600869\" _msthash=\"407\">Realizar gestão de Trade Marketing e acompanhamento das campanhas no PDV (Ponto de Vendas);</font><br><font _mstmutation=\"1\" _msttexthash=\"3863314\" _msthash=\"408\">Impulsionar a venda parcelada através do CREDMOURA como estratégia de negócio;</font><br><font _mstmutation=\"1\" _msttexthash=\"1924871\" _msthash=\"409\">Promover e garantir a evolução do NPS no distribuidor.</font></font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"2376751\" _msthash=\"295\">Conhecimento em PowerBI; <br _istranslated=\"1\">Diferencial MBA ou Pós-graduação. <font _mstmutation=\"1\" _msttexthash=\"1924871\" _msthash=\"409\" _istranslated=\"1\"><br _istranslated=\"1\"></font></font></p>\n<p _msttexthash=\"6685016\" _msthash=\"296\"><strong><strong>Requisitos Obrigatórios</strong></strong><br><font _mstmutation=\"1\" _msttexthash=\"263744\" _msthash=\"410\">Excel Avançado;</font><br><font _mstmutation=\"1\" _msttexthash=\"1625208\" _msthash=\"411\">Experiência com Gestão e Análise de Indicadores;</font><br><font _mstmutation=\"1\" _msttexthash=\"2350972\" _msthash=\"412\">Conhecimento em planejamento, roteirização de vendas e CRM;</font><br><font _mstmutation=\"1\" _msttexthash=\"2627430\" _msthash=\"413\">Disponibilidade para viagens constantes (cerca de 15 dias ao mês).</font></p>\n<p _msttexthash=\"3680599\" _msthash=\"297\"><br></p>","country":"Brazil","state":"State of São Paulo","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1700352,"hash":"QY7YVVVV","position_name":"Consultor Jira Pleno","description":"<p>Nosso cliente é do ramo de telecomunicações (internet banda larga e fibra óptica, TV e telefone fixo).</p>\n<p><strong>VAGA: Consultor Jira Pleno </strong></p>\n<ul><li>Experiência: Jira Service Management, Jira Software e ITSM. </li><li>Atividades: Administrar, levantar, criar e impeachment de fluxos automatizados. </li></ul>\n<p><strong>Mandatório:</strong></p>\n<ul><li>Modelo de Trabalho: Híbrido (cada 15 dias - Vila Olimpia  SP)</li><li>Regime de Contratação: Prestador de Serviços </li><li>Senioridade: Pleno / Sênior</li></ul><p>Salário máximo: 10.500,00 ou 62,50/hora - PJ</p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1780223,"hash":"L963WR6Y","position_name":"Consultor SAP BTP","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Consultor SAP BTP com experiência comprovada na plataforma \"Business Technology Platform\"&nbsp;<br></p>\n<p>Desenvolvimento de novas integrações entre SAP e sistemas externos através da plataforma BTP</p>\n<p>Conhecimentos de ETL e transformação de dados</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Ter utilizado e participado de projetos SAP com a plataforma BTP</p><p>﻿<strong><strong>﻿Informações Adicionais:  <br>﻿</strong></strong>Contratação: PJ<br>Modelo de trabalho: Remoto</p>\n<p><br></p>","country":"Brazil","state":"SP","city":"Tatuí","address":"","zipcode":"","location_display":"Tatuí, SP, Brazil","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828792,"hash":"L64RXV7R","position_name":"Control & Metrology Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Control &amp; Metrology&nbsp;Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Recognized experience in three-dimensional control media and metrology</li><li>Equipment purchasing process</li><li>Creation of ranges/control programs and their validation</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955720,"hash":"L649VYR5","position_name":"Coordenador de Design de interiores","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"4743\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"4742\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"4741\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"4740\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"4739\"></font></p>\n<p _msttexthash=\"58125782\" _msthash=\"4978\"><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"4739\">Liderar e coordenar as atividades do time de Design, acompanhando todo o processo, desde a criação até a prototipação final, junto a equipe de designers, garantindo os processos de Design, as premissas e linguagem definidas para o produto, realizando entregas dentro dos prazos, custos estimados, alinhado com  estratégia da Empresa.</font></p><br><p></p>\n<p _msttexthash=\"6685016\" _msthash=\"4738\"><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p _msttexthash=\"22645519\" _msthash=\"4984\">Aprovar/reprovar as soluções de Design/Estilo de interior que são criadas pela equipe de forma virtual ou física, dando o devido direcionamento, a fim de atender os objetivos definidos para o novo produto.</p>\n<p _msttexthash=\"11462776\" _msthash=\"4983\">Priorizar soluções na criação para o aumento da satisfação do cliente em relação ao produto, a lealdade à marca e a diferenciação de mercado.</p>\n<p _msttexthash=\"14614444\" _msthash=\"4982\">Prestar qualquer tipo de ajuda, suporte ou apoio para a equipe, criando condições para os colaboradores poderem realizar o seu trabalho da melhor forma possível.</p>\n<p _msttexthash=\"16026283\" _msthash=\"4981\">Gerir o orçamento disponível para a área, monitorando o gasto com pessoal, suporte tecnológico, investimentos para área e inovação, propiciando um ambiente criativo.</p>\n<p _msttexthash=\"62767094\" _msthash=\"4980\">Administrar a interface de trabalhos junto às demais áreas da empresa, a fim de resolver problemas, remover impedimentos e conciliar pontos de vista diferentes entre departamento de Engenharia, Design, Marketing, Estratégia, Vendas e outros, promovendo condições para a entrega da melhor experiência de uso possível dos produtos da empresa.</p>\n<p _msttexthash=\"12847718\" _msthash=\"4979\">Assegurar que o produto resolva o problema do usuário final, orientando pesquisas e testes de usuários (UX), identificando a real necessidade do cliente.</p>\n<p></p>\n<p _msttexthash=\"3680599\" _msthash=\"4737\"><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p _msttexthash=\"874068\" _msthash=\"4986\">Experiencia em Design automotivo;</p>\n<p _msttexthash=\"855569\" _msthash=\"4985\">Experiencia em gestão de pessoas.</p>\n<p><strong _msttexthash=\"404118\" _msthash=\"4988\">Formação Acadêmica</strong></p>\n<p _msttexthash=\"1148719\" _msthash=\"4987\">Superior Completo em Designer de Produto</p>\n<p></p>\n<p _msttexthash=\"2734823\" _msthash=\"4736\"><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><br></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1815436,"hash":"LR47W4VR","position_name":"Coordenador de Eng. Desenvolvimento","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p>\n<p>Desenvolver produtos para o segmento automotivo, principalmente carrocerias. Atuar como chief engineer liderando equipes multidisciplinares (estrutural, acabamento eletrônica) para o desenvolvimento do projeto.</p>\n<p></p>\n<p>Desenvolver produtos de acordo com as necessidades da organização e do mercado</p>\n<p>Gerir os squads multidisciplinares de desenvolvimento de produtos</p>\n<p>Propor ações de melhoria e otimização</p>\n<p>Gestão de orçamento do custo fixo e dos projetos</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Ensino Superior Concluído em áreas técnicas;</p>\n<p>Especialização em gestão de projetos ou gestão de pessoas ou inovação;</p>\n<p>Inglês + Nivel fluente;</p>\n<p>07 anos de Experiência em desenvolvimento de produtos complexos no segmento automotivo ou relacionado;</p>\n<p></p>\n<p>TURNO DE TRABALHO (HORÁRIO):&nbsp;Das 7:30 até 17:18</p>\n<p><br></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1776242,"hash":"L4YRY3XV","position_name":"Coordenador de Recursos Humanos","description":"<p>Junte-se a PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Gerenciar e fazer cumprir as políticas e programas de Treinamento através das necessidades levantadas pelas Áreas, visando manter os funcionários capacitados e atualizados para desempenhar suas funções.<br>Gerenciar as atividades de Recrutamento e Seleção para que, de acordo com as necessidades das Áreas, sejam selecionadas os melhores profissionais para a Empresa.<br>Administrar os benefícios oferecidos pela empresa, através das ocorrências verificadas, visando manter um nível adequado de atendimento ao menor custo possível.<br>Gerenciar as atividades relacionadas aos Processos Trabalhistas movidos contra a empresa na Justiça do Trabalho, atuando internamente nas causas e orientando na execução dos trabalhos, visando minimizar os passivos existentes e prevenção futura.<br>Administrar, orientar e normatizar a rotina da área de serviços gerais: segurança, limpeza e Frota de veículos, com o objetivo de garantir a qualidade e eficiência dos serviços prestados e atender às necessidades da empresa.<br>Acompanhar e controlar o custo do trabalho, verificando se o mesmo está dentro do definido, conforme as previsões.<br>Garantir a elaboração e cumprimento do budget da Área, através do controle efetivo das despesas e investimentos, acompanhando  as variações entre os valores orçados e realizados, bem como identificando as causas, com a finalidade de implementar as ações preventivas e corretivas, quando necessário.<br>Participar, junto com a Diretoria da Empresa, das decisões estratégicas que visem garantir o sucesso da unidade de sua competência.<br>Prever informações referentes ao custo do trabalho, despesas de responsabilidade da área de RH, analisando os impactos e promovendo ações para garantir o cumprimento estabelecido no plano estratégico da Empresa.<br>Definir junto à Diretoria estratégias de Recursos Humanos, relacionadas aos objetivos da empresa.<br>Analisar o relatório de indicadores de RH, verificando a evolução dos indicadores, bem como verificando se as informações estão dentro dos objetivos definidos, visando a elaboração de  planos de ações quando necessário.<br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong> </strong><br>IATF, Legislação trabalhista, Recrutamento e seleção, Treinamento e desenvolvimento, Cargos e salários, Administração pessoal, Inglês  avançado</p><p>Experiência em empresas do ramo automotivo ou de autopeças.&nbsp;</p>\n<p><strong><strong>Requisitos Complementares</strong> </strong><br>Formação Superior: Psicologia, Administração, Gestão de RH, ou áreas correlatas. Uma pós-graduação ou especialização em Gestão de RH, Direito Trabalhista, ou Gestão de Pessoas é um diferencial; Conhecimentos em Legislação Trabalhista; Habilidades em Tecnologia; Competências Interpessoais; Habilidades Analíticas; Gestão de Tempo e Projetos; Estratégia de Negócios e Visão Global; Atualização Constante; Competências em Desenvolvimento de Pessoas. </p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"Hortolândia","address":"","zipcode":"","location_display":"Hortolândia, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955743,"hash":"L536RX73","position_name":"Coordenador Manutenção","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"7764\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"7763\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"7762\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"7761\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"7760\"><font _mstmutation=\"1\" _msttexthash=\"3467945\" _msthash=\"7910\">Experiência em liderança de manutenção no setor industrial/automotivo.</font><br><font _mstmutation=\"1\" _msttexthash=\"2263677\" _msthash=\"7911\">Experiência em gestão de manutenção predial e facilities</font><br><font _mstmutation=\"1\" _msttexthash=\"3150225\" _msthash=\"7912\">Experiência em gestão de manutenção de cabines de alta / média tensão</font><br><font _mstmutation=\"1\" _msttexthash=\"2026193\" _msthash=\"7913\">Conhecimento em Auditorias IATF 16949, ISO 14001, ISO 50001 e ISO 45001.</font><br><font _mstmutation=\"1\" _msttexthash=\"423059\" _msthash=\"7914\">Gestão de spare parts.</font><br><font _mstmutation=\"1\" _msttexthash=\"841594\" _msthash=\"7915\">Gestão de contratos de terceiros.</font><br><font _mstmutation=\"1\" _msttexthash=\"6069193\" _msthash=\"7916\">Experiência em elaboração de especificações técnicas para cotações de serviços / equipamentos.</font></font><br></p>\n<p _msttexthash=\"6685016\" _msthash=\"7759\"><strong><strong>Requisitos Obrigatórios</strong></strong><br><font _mstmutation=\"1\" _msttexthash=\"4912414\" _msthash=\"7891\">Superior Completo - Graduação em Engenharia (Mecânica, Elétrica, Mecatrônica ou similar</font></p>\n<p _msttexthash=\"6685016\" _msthash=\"7759\"><font _mstmutation=\"1\" _msttexthash=\"147823\" _msthash=\"7895\"><font _mstmutation=\"1\" _msttexthash=\"147823\" _msthash=\"7896\">EXPERIÊNCIA&nbsp;</font><font _mstmutation=\"1\"></font><font _mstmutation=\"1\" _msttexthash=\"58656\" _msthash=\"7897\">5 anos</font></font><font _mstmutation=\"1\"></font></p>\n<p _msttexthash=\"3680599\" _msthash=\"7758\"><strong><strong>Requisitos Complementares</strong></strong><br><font _mstmutation=\"1\" _msttexthash=\"2583594\" _msthash=\"7898\">Gestão de procedimentos de manutenção preventiva e preditiva</font><br><font _mstmutation=\"1\" _msttexthash=\"8607521\" _msthash=\"7899\">Planejar e coordenar manutenções preditivas, preventivas e corretivas, organizando recursos e paradas de equipamentos.</font><br><font _mstmutation=\"1\" _msttexthash=\"3336099\" _msthash=\"7900\">Oferecer suporte técnico às áreas de Engenharia de Manufatura e Processo.</font><br><font _mstmutation=\"1\" _msttexthash=\"611377\" _msthash=\"7901\">Gerir manutenção predial.</font><br><font _mstmutation=\"1\" _msttexthash=\"7954700\" _msthash=\"7902\">Analisar e monitorar semanalmente indicadores de manutenções, propor planos de ações para evolução contínua.</font><br><font _mstmutation=\"1\" _msttexthash=\"2654054\" _msthash=\"7903\">Desenvolver estratégias de redução de custos em manutenção.</font><br><font _mstmutation=\"1\" _msttexthash=\"4806009\" _msthash=\"7904\">Realizar reuniões com a equipe de manutenção para definir prioridades e alinhar ações.</font><br><font _mstmutation=\"1\" _msttexthash=\"1308619\" _msthash=\"7905\">Gerir seleção e desenvolvimento da equipe.</font><br><font _mstmutation=\"1\" _msttexthash=\"5819827\" _msthash=\"7906\">Gerir de contratos de manutenção com fornecedores, seja de mão-de-obra técnica e / ou equipamentos.</font><br><font _mstmutation=\"1\" _msttexthash=\"3502434\" _msthash=\"7907\">Auxiliar no desenvolvimento de novos fornecedores para peças e serviços.</font><br><font _mstmutation=\"1\" _msttexthash=\"2246816\" _msthash=\"7908\">Vivência em ambientes com diversos níveis de automação.</font><br><font _mstmutation=\"1\"></font><font _mstmutation=\"1\"></font><font _mstmutation=\"1\" _msttexthash=\"297141\" _msthash=\"7909\">Inglês Avançado</font></p>\n<p _msttexthash=\"2734823\" _msthash=\"7757\"><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><br></p>","country":"Brazil","state":"State of São Paulo","city":"Hortolândia","address":"","zipcode":"","location_display":"Hortolândia, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938227,"hash":"QX3W83XR","position_name":"Cost Serial Life Cost Performance","description":"<p></p>\n<p>Join the PTC Group family <br><br>We are always looking for talents who have a passion for progress, innovation, and curiosity to tackle the challenges that affect our society today. <br><br>We are a multinational Engineering &amp; IT company, being reliable partners of major global companies. Focused on the future, we are driven by the pursuit of excellence in everything we do. </p>\n<p><strong><strong>Responsibilities and Tasks of the Job<br>﻿<br>﻿﻿Cost Serial Life Cost Performance / Car Line A-B Segment.</strong></strong><br></p>\n<ul><li>VO Carline Pilot, for Palomar plant models (CMP family). Phisycal presence in Palomar plant at least 2 days a week</li><li>Tasks:<ul><li>ensure implementation and financial accounting of cost evolution/saving</li><li>enhance idea generation</li><li>promote efficiency       </li></ul></li></ul>\n<ul><li>Required location: Argentina, close to Stellantis Palomar Plant</li></ul>\n<p><br></p>\n<p><strong><strong><strong>Mandatory Skills</strong></strong></strong><br>Experience in design, release or processing role; or other credentials <br>in combination with relevant experience in developing variable and/or <br>tooling costs for automotive components<br> Automotive knowledge of production methods and development <br>processes in the vehicle sector, focus on metal sheet stamping and <br>body in white manufacturing processes<br> Automotive components basic economical knowledge (cost factors, <br>cost analysis methods, etc.)<br> Detail oriented with ability to manage multiple programs and cost <br>details simultaneously<br> Solid leadership, interpersonal and communication skills with English <br>as official language for communication (written and oral</p>\n<p><strong><strong>Complementary Skills</strong></strong><br>Proficiency in NX and Teamcenter.<br> Activity based costing experience or experience in cost model <br>development</p>\n<p><strong><strong>What we offer</strong></strong><br>(write)</p>","country":"Argentina","state":"Buenos Aires Province","city":"Palomar","address":"","zipcode":"","location_display":"Palomar, Buenos Aires Province, Argentina","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:54 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=8","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=6","results":[{"id":1842489,"hash":"L393465V","position_name":"Commercial Director","description":"<p>Nos encontramos en la búsqueda de un <strong>Director/a Comercial</strong> para el territorio Español, para una compañía&nbsp;﻿líder&nbsp;de protección contra incendios en España. Actualmente cuenta con&nbsp;más de 150 profesionales, más de 25.000 clientes, y se encuentran&nbsp;en pleno proceso de expansión.&nbsp;</p>\n<p><strong>Responsabilidades:</strong><br></p>\n<ul><li><strong>Dirección del Equipo Comercial:</strong> Liderar y dirigir el equipo de ventas en España, estableciendo objetivos, monitoreando el rendimiento y proporcionando mentoría y apoyo continuo.</li><li><strong>Gestión de Cuentas Clave:</strong> Gestionar personalmente las cuentas más grandes y estratégicas, asegurando un alto nivel de satisfacción del cliente y oportunidades de ventas recurrentes.</li><li><strong>Crecimiento Orgánico:</strong> Lograr un crecimiento orgánico de al menos un 10% en los servicios de mantenimiento, identificando y aprovechando oportunidades de mercado y optimizando las estrategias de ventas.</li><li><strong>Estructuración de Procesos de Ventas:</strong> Desarrollar y optimizar la estructura del equipo de ventas, incluyendo la implementación de procesos y herramientas eficaces para maximizar el rendimiento y la eficiencia.</li><li><strong>Gestión de Presupuestos y Ofertas:</strong> Supervisar la creación y aprobación de presupuestos y ofertas, asegurando la rentabilidad deseada por la empresa.</li><li><strong>Atención al Cliente:</strong> Proporcionar soporte y resolución de problemas para clientes clave, manteniendo una comunicación fluida y eficaz.</li><li><strong>Administración de Contratos:</strong> Coordinar la redacción, revisión y firma de contratos, asegurando el cumplimiento de plazos y términos.</li><li><strong>Reportes y Análisis:</strong> Preparar informes de ventas, analizar datos para identificar oportunidades de mejora y áreas de crecimiento.</li></ul>\n<p><strong>Requisitos:</strong></p>\n<ul><li>Experiencia sólida en gestión de equipos comerciales y ventas; teniendo un historial de éxito en protección contra incendios (PCI) o sectores similares (e.g., ascensores, HVAC, facility management, etc.).</li><li>Habilidad para gestionar grandes cuentas y mantener relaciones sólidas con los clientes.</li><li>Excelentes habilidades de liderazgo, comunicación y resolución de problemas.</li><li>Habilidad numérica y competencia en el uso de sistemas CRM y otras herramientas de ventas.</li><li>Disponibilidad para desplazarse regularmente dentro de España según las necesidades del negocio.</li></ul>\n<p><br></p><p>- ﻿Hor<span style=\"font-family: inherit; font-size: 0.875rem;\">ario: Jornada completa</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">- Incorporación: Septiembre 2024</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">- Contrato indefinido</span></p><p>- Lugar de trabajo: alguna de las sedes en Barcelona (Gavà, Rubí, o Granollers)</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">- Disponibilidad para viajar por toda España para visitar clientes o las diferentes sedes</span><br></p><p>operativas</p>\n<p><br></p>\n<p><strong>Si cumples con estos requisitos y estás interesado/a en unirte al equipo, te invitamos a postularte para esta emocionante oportunidad. ¡Esperamos recibir tu candidatura!﻿</strong></p>","country":"Spain","state":"CT","city":"Barcelona","address":"","zipcode":"","location_display":"Barcelona, CT, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1834624,"hash":"LR4R9X9R","position_name":"Consultor de Gestão","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"291\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"292\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"293\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"294\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"295\"><font _mstmutation=\"1\" _msttexthash=\"17856410\" _msthash=\"401\">Atuar junto aos distribuidores nos processos de Gestão de Vendas, atuando para o alcance das metas de volume de vendas, TPV (faturamento de cartão de crédito) e NPS dos distribuidores;</font><br><font _mstmutation=\"1\" _msttexthash=\"1912326\" _msthash=\"402\">Realizar análises de mercado e gestão de indicadores;</font><br><font _mstmutation=\"1\" _msttexthash=\"1155908\" _msthash=\"403\">Realiza a gestão da carteira de clientes;</font><br><font _mstmutation=\"1\" _msttexthash=\"7887867\" _msthash=\"404\">Capacitar as equipes de vendas nos processos de gestão de vendas, sistemas Vendas Rede Moura e procedimentos de vendas;</font><br><font _mstmutation=\"1\" _msttexthash=\"2015195\" _msthash=\"405\">Promover o Sistema Moura de Gestão nas equipes de Vendas;</font><br><font _mstmutation=\"1\" _msttexthash=\"4059653\" _msthash=\"406\">Suportar o distribuidor na construção e execução de Planos de Ação e Anomalias;</font><br><font _mstmutation=\"1\" _msttexthash=\"4600869\" _msthash=\"407\">Realizar gestão de Trade Marketing e acompanhamento das campanhas no PDV (Ponto de Vendas);</font><br><font _mstmutation=\"1\" _msttexthash=\"3863314\" _msthash=\"408\">Impulsionar a venda parcelada através do CREDMOURA como estratégia de negócio;</font><br><font _mstmutation=\"1\" _msttexthash=\"1924871\" _msthash=\"409\">Promover e garantir a evolução do NPS no distribuidor.</font></font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"2376751\" _msthash=\"295\">Conhecimento em PowerBI; <br _istranslated=\"1\">Diferencial MBA ou Pós-graduação. <font _mstmutation=\"1\" _msttexthash=\"1924871\" _msthash=\"409\" _istranslated=\"1\"><br _istranslated=\"1\"></font></font></p>\n<p _msttexthash=\"6685016\" _msthash=\"296\"><strong><strong>Requisitos Obrigatórios</strong></strong><br><font _mstmutation=\"1\" _msttexthash=\"263744\" _msthash=\"410\">Excel Avançado;</font><br><font _mstmutation=\"1\" _msttexthash=\"1625208\" _msthash=\"411\">Experiência com Gestão e Análise de Indicadores;</font><br><font _mstmutation=\"1\" _msttexthash=\"2350972\" _msthash=\"412\">Conhecimento em planejamento, roteirização de vendas e CRM;</font><br><font _mstmutation=\"1\" _msttexthash=\"2627430\" _msthash=\"413\">Disponibilidade para viagens constantes (cerca de 15 dias ao mês).</font></p>\n<p _msttexthash=\"3680599\" _msthash=\"297\"><br></p>","country":"Brazil","state":"State of São Paulo","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1700352,"hash":"QY7YVVVV","position_name":"Consultor Jira Pleno","description":"<p>Nosso cliente é do ramo de telecomunicações (internet banda larga e fibra óptica, TV e telefone fixo).</p>\n<p><strong>VAGA: Consultor Jira Pleno </strong></p>\n<ul><li>Experiência: Jira Service Management, Jira Software e ITSM. </li><li>Atividades: Administrar, levantar, criar e impeachment de fluxos automatizados. </li></ul>\n<p><strong>Mandatório:</strong></p>\n<ul><li>Modelo de Trabalho: Híbrido (cada 15 dias - Vila Olimpia  SP)</li><li>Regime de Contratação: Prestador de Serviços </li><li>Senioridade: Pleno / Sênior</li></ul><p>Salário máximo: 10.500,00 ou 62,50/hora - PJ</p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1780223,"hash":"L963WR6Y","position_name":"Consultor SAP BTP","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Consultor SAP BTP com experiência comprovada na plataforma \"Business Technology Platform\"&nbsp;<br></p>\n<p>Desenvolvimento de novas integrações entre SAP e sistemas externos através da plataforma BTP</p>\n<p>Conhecimentos de ETL e transformação de dados</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Ter utilizado e participado de projetos SAP com a plataforma BTP</p><p>﻿<strong><strong>﻿Informações Adicionais:  <br>﻿</strong></strong>Contratação: PJ<br>Modelo de trabalho: Remoto</p>\n<p><br></p>","country":"Brazil","state":"SP","city":"Tatuí","address":"","zipcode":"","location_display":"Tatuí, SP, Brazil","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828792,"hash":"L64RXV7R","position_name":"Control & Metrology Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Control &amp; Metrology&nbsp;Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Recognized experience in three-dimensional control media and metrology</li><li>Equipment purchasing process</li><li>Creation of ranges/control programs and their validation</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955720,"hash":"L649VYR5","position_name":"Coordenador de Design de interiores","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"4743\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"4742\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"4741\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"4740\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"4739\"></font></p>\n<p _msttexthash=\"58125782\" _msthash=\"4978\"><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"4739\">Liderar e coordenar as atividades do time de Design, acompanhando todo o processo, desde a criação até a prototipação final, junto a equipe de designers, garantindo os processos de Design, as premissas e linguagem definidas para o produto, realizando entregas dentro dos prazos, custos estimados, alinhado com  estratégia da Empresa.</font></p><br><p></p>\n<p _msttexthash=\"6685016\" _msthash=\"4738\"><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p _msttexthash=\"22645519\" _msthash=\"4984\">Aprovar/reprovar as soluções de Design/Estilo de interior que são criadas pela equipe de forma virtual ou física, dando o devido direcionamento, a fim de atender os objetivos definidos para o novo produto.</p>\n<p _msttexthash=\"11462776\" _msthash=\"4983\">Priorizar soluções na criação para o aumento da satisfação do cliente em relação ao produto, a lealdade à marca e a diferenciação de mercado.</p>\n<p _msttexthash=\"14614444\" _msthash=\"4982\">Prestar qualquer tipo de ajuda, suporte ou apoio para a equipe, criando condições para os colaboradores poderem realizar o seu trabalho da melhor forma possível.</p>\n<p _msttexthash=\"16026283\" _msthash=\"4981\">Gerir o orçamento disponível para a área, monitorando o gasto com pessoal, suporte tecnológico, investimentos para área e inovação, propiciando um ambiente criativo.</p>\n<p _msttexthash=\"62767094\" _msthash=\"4980\">Administrar a interface de trabalhos junto às demais áreas da empresa, a fim de resolver problemas, remover impedimentos e conciliar pontos de vista diferentes entre departamento de Engenharia, Design, Marketing, Estratégia, Vendas e outros, promovendo condições para a entrega da melhor experiência de uso possível dos produtos da empresa.</p>\n<p _msttexthash=\"12847718\" _msthash=\"4979\">Assegurar que o produto resolva o problema do usuário final, orientando pesquisas e testes de usuários (UX), identificando a real necessidade do cliente.</p>\n<p></p>\n<p _msttexthash=\"3680599\" _msthash=\"4737\"><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p _msttexthash=\"874068\" _msthash=\"4986\">Experiencia em Design automotivo;</p>\n<p _msttexthash=\"855569\" _msthash=\"4985\">Experiencia em gestão de pessoas.</p>\n<p><strong _msttexthash=\"404118\" _msthash=\"4988\">Formação Acadêmica</strong></p>\n<p _msttexthash=\"1148719\" _msthash=\"4987\">Superior Completo em Designer de Produto</p>\n<p></p>\n<p _msttexthash=\"2734823\" _msthash=\"4736\"><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><br></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1815436,"hash":"LR47W4VR","position_name":"Coordenador de Eng. Desenvolvimento","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p>\n<p>Desenvolver produtos para o segmento automotivo, principalmente carrocerias. Atuar como chief engineer liderando equipes multidisciplinares (estrutural, acabamento eletrônica) para o desenvolvimento do projeto.</p>\n<p></p>\n<p>Desenvolver produtos de acordo com as necessidades da organização e do mercado</p>\n<p>Gerir os squads multidisciplinares de desenvolvimento de produtos</p>\n<p>Propor ações de melhoria e otimização</p>\n<p>Gestão de orçamento do custo fixo e dos projetos</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Ensino Superior Concluído em áreas técnicas;</p>\n<p>Especialização em gestão de projetos ou gestão de pessoas ou inovação;</p>\n<p>Inglês + Nivel fluente;</p>\n<p>07 anos de Experiência em desenvolvimento de produtos complexos no segmento automotivo ou relacionado;</p>\n<p></p>\n<p>TURNO DE TRABALHO (HORÁRIO):&nbsp;Das 7:30 até 17:18</p>\n<p><br></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1776242,"hash":"L4YRY3XV","position_name":"Coordenador de Recursos Humanos","description":"<p>Junte-se a PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>Gerenciar e fazer cumprir as políticas e programas de Treinamento através das necessidades levantadas pelas Áreas, visando manter os funcionários capacitados e atualizados para desempenhar suas funções.<br>Gerenciar as atividades de Recrutamento e Seleção para que, de acordo com as necessidades das Áreas, sejam selecionadas os melhores profissionais para a Empresa.<br>Administrar os benefícios oferecidos pela empresa, através das ocorrências verificadas, visando manter um nível adequado de atendimento ao menor custo possível.<br>Gerenciar as atividades relacionadas aos Processos Trabalhistas movidos contra a empresa na Justiça do Trabalho, atuando internamente nas causas e orientando na execução dos trabalhos, visando minimizar os passivos existentes e prevenção futura.<br>Administrar, orientar e normatizar a rotina da área de serviços gerais: segurança, limpeza e Frota de veículos, com o objetivo de garantir a qualidade e eficiência dos serviços prestados e atender às necessidades da empresa.<br>Acompanhar e controlar o custo do trabalho, verificando se o mesmo está dentro do definido, conforme as previsões.<br>Garantir a elaboração e cumprimento do budget da Área, através do controle efetivo das despesas e investimentos, acompanhando  as variações entre os valores orçados e realizados, bem como identificando as causas, com a finalidade de implementar as ações preventivas e corretivas, quando necessário.<br>Participar, junto com a Diretoria da Empresa, das decisões estratégicas que visem garantir o sucesso da unidade de sua competência.<br>Prever informações referentes ao custo do trabalho, despesas de responsabilidade da área de RH, analisando os impactos e promovendo ações para garantir o cumprimento estabelecido no plano estratégico da Empresa.<br>Definir junto à Diretoria estratégias de Recursos Humanos, relacionadas aos objetivos da empresa.<br>Analisar o relatório de indicadores de RH, verificando a evolução dos indicadores, bem como verificando se as informações estão dentro dos objetivos definidos, visando a elaboração de  planos de ações quando necessário.<br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong> </strong><br>IATF, Legislação trabalhista, Recrutamento e seleção, Treinamento e desenvolvimento, Cargos e salários, Administração pessoal, Inglês  avançado</p><p>Experiência em empresas do ramo automotivo ou de autopeças.&nbsp;</p>\n<p><strong><strong>Requisitos Complementares</strong> </strong><br>Formação Superior: Psicologia, Administração, Gestão de RH, ou áreas correlatas. Uma pós-graduação ou especialização em Gestão de RH, Direito Trabalhista, ou Gestão de Pessoas é um diferencial; Conhecimentos em Legislação Trabalhista; Habilidades em Tecnologia; Competências Interpessoais; Habilidades Analíticas; Gestão de Tempo e Projetos; Estratégia de Negócios e Visão Global; Atualização Constante; Competências em Desenvolvimento de Pessoas. </p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"Hortolândia","address":"","zipcode":"","location_display":"Hortolândia, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955743,"hash":"L536RX73","position_name":"Coordenador Manutenção","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"7764\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"7763\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"7762\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"7761\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"7760\"><font _mstmutation=\"1\" _msttexthash=\"3467945\" _msthash=\"7910\">Experiência em liderança de manutenção no setor industrial/automotivo.</font><br><font _mstmutation=\"1\" _msttexthash=\"2263677\" _msthash=\"7911\">Experiência em gestão de manutenção predial e facilities</font><br><font _mstmutation=\"1\" _msttexthash=\"3150225\" _msthash=\"7912\">Experiência em gestão de manutenção de cabines de alta / média tensão</font><br><font _mstmutation=\"1\" _msttexthash=\"2026193\" _msthash=\"7913\">Conhecimento em Auditorias IATF 16949, ISO 14001, ISO 50001 e ISO 45001.</font><br><font _mstmutation=\"1\" _msttexthash=\"423059\" _msthash=\"7914\">Gestão de spare parts.</font><br><font _mstmutation=\"1\" _msttexthash=\"841594\" _msthash=\"7915\">Gestão de contratos de terceiros.</font><br><font _mstmutation=\"1\" _msttexthash=\"6069193\" _msthash=\"7916\">Experiência em elaboração de especificações técnicas para cotações de serviços / equipamentos.</font></font><br></p>\n<p _msttexthash=\"6685016\" _msthash=\"7759\"><strong><strong>Requisitos Obrigatórios</strong></strong><br><font _mstmutation=\"1\" _msttexthash=\"4912414\" _msthash=\"7891\">Superior Completo - Graduação em Engenharia (Mecânica, Elétrica, Mecatrônica ou similar</font></p>\n<p _msttexthash=\"6685016\" _msthash=\"7759\"><font _mstmutation=\"1\" _msttexthash=\"147823\" _msthash=\"7895\"><font _mstmutation=\"1\" _msttexthash=\"147823\" _msthash=\"7896\">EXPERIÊNCIA&nbsp;</font><font _mstmutation=\"1\"></font><font _mstmutation=\"1\" _msttexthash=\"58656\" _msthash=\"7897\">5 anos</font></font><font _mstmutation=\"1\"></font></p>\n<p _msttexthash=\"3680599\" _msthash=\"7758\"><strong><strong>Requisitos Complementares</strong></strong><br><font _mstmutation=\"1\" _msttexthash=\"2583594\" _msthash=\"7898\">Gestão de procedimentos de manutenção preventiva e preditiva</font><br><font _mstmutation=\"1\" _msttexthash=\"8607521\" _msthash=\"7899\">Planejar e coordenar manutenções preditivas, preventivas e corretivas, organizando recursos e paradas de equipamentos.</font><br><font _mstmutation=\"1\" _msttexthash=\"3336099\" _msthash=\"7900\">Oferecer suporte técnico às áreas de Engenharia de Manufatura e Processo.</font><br><font _mstmutation=\"1\" _msttexthash=\"611377\" _msthash=\"7901\">Gerir manutenção predial.</font><br><font _mstmutation=\"1\" _msttexthash=\"7954700\" _msthash=\"7902\">Analisar e monitorar semanalmente indicadores de manutenções, propor planos de ações para evolução contínua.</font><br><font _mstmutation=\"1\" _msttexthash=\"2654054\" _msthash=\"7903\">Desenvolver estratégias de redução de custos em manutenção.</font><br><font _mstmutation=\"1\" _msttexthash=\"4806009\" _msthash=\"7904\">Realizar reuniões com a equipe de manutenção para definir prioridades e alinhar ações.</font><br><font _mstmutation=\"1\" _msttexthash=\"1308619\" _msthash=\"7905\">Gerir seleção e desenvolvimento da equipe.</font><br><font _mstmutation=\"1\" _msttexthash=\"5819827\" _msthash=\"7906\">Gerir de contratos de manutenção com fornecedores, seja de mão-de-obra técnica e / ou equipamentos.</font><br><font _mstmutation=\"1\" _msttexthash=\"3502434\" _msthash=\"7907\">Auxiliar no desenvolvimento de novos fornecedores para peças e serviços.</font><br><font _mstmutation=\"1\" _msttexthash=\"2246816\" _msthash=\"7908\">Vivência em ambientes com diversos níveis de automação.</font><br><font _mstmutation=\"1\"></font><font _mstmutation=\"1\"></font><font _mstmutation=\"1\" _msttexthash=\"297141\" _msthash=\"7909\">Inglês Avançado</font></p>\n<p _msttexthash=\"2734823\" _msthash=\"7757\"><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><br></p>","country":"Brazil","state":"State of São Paulo","city":"Hortolândia","address":"","zipcode":"","location_display":"Hortolândia, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1964796,"hash":"LR453696","position_name":"Cost Eng Electromechanical - HV Battery Systems","description":"<p></p>\n<p _msttexthash=\"823172051\" _msthash=\"295\">Junte-se à família <br _istranslated=\"1\"><br _istranslated=\"1\">PTC Group Estamos sempre à procura de talentos que tenham paixão pelo progresso, inovação e curiosidade para enfrentar os desafios que afetam nossa sociedade hoje. <br _istranslated=\"1\"><br _istranslated=\"1\">Somos uma empresa multinacional de Engenharia e TI, sendo parceiros confiáveis de grandes empresas globais. Focados no futuro, somos movidos pela busca da excelência em tudo o que fazemos. </p>\n<p><strong><strong _msttexthash=\"1148199\" _msthash=\"294\">Responsabilidades e tarefas do trabalho</strong></strong><br></p>\n<ul><li _msttexthash=\"2660229\" _msthash=\"292\">Experiência de trabalho direto em design de Eletrônica e E-bombas</li><li _msttexthash=\"551408\" _msthash=\"293\">Profundo conhecimento de:</li></ul>\n<ul><ul><li _msttexthash=\"1582438\" _msthash=\"288\">Arquitetura e design de eletrônica de potência</li><li _msttexthash=\"655876\" _msthash=\"289\">Semicondutores e Magnetismo</li><li _msttexthash=\"451685\" _msthash=\"290\">Tecnologia e materiais</li><li _msttexthash=\"606866\" _msthash=\"291\">Processo de produção de PCB</li></ul></ul>\n<ul><li _msttexthash=\"8832811\" _msthash=\"287\">Compreensão profunda dos processos de fundição sob pressão, processo de estampagem e circuitos impressos flexíveis (FPC).</li></ul>\n<p><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"11755484\" _msthash=\"286\"><strong _mstmutation=\"1\" _istranslated=\"1\"><strong _istranslated=\"1\"><strong _istranslated=\"1\">Habilidades obrigatórias</strong></strong></strong><br _mstmutation=\"1\" _istranslated=\"1\">Bacharelado em engenharia mecânica e experiência de trabalho direto em design de eletrônicos e bombas eletrônicas</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"731315\" _msthash=\"285\"><strong _mstmutation=\"1\" _istranslated=\"1\"><strong _istranslated=\"1\">Fuso</strong></strong><br _mstmutation=\"1\" _istranslated=\"1\">horário preferido: MÉXICO</font><br></p>\n<p _msttexthash=\"1300910\" _msthash=\"284\">- Tipo de solicitação de trabalho: Híbrido</p>\n<p _msttexthash=\"1430611\" _msthash=\"283\">- Nível de inglês solicitado: intermediário</p>\n<p><br></p>","country":"Mexico","state":"Coahuila","city":"Ramos Arizpe","address":"","zipcode":"","location_display":"Ramos Arizpe, Coahuila, Mexico","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":true}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:40 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=8
@@ -534,11 +534,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:54 GMT
+      - Tue, 30 Jul 2024 16:28:40 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '30633'
+      - '29644'
       Connection:
       - keep-alive
       Server:
@@ -559,8 +559,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=9","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=7","results":[{"id":1948314,"hash":"QWYV7879","position_name":"Database Engineer","description":"<p></p>\n<p>A PTC Group está a recrutar um Database Engineer ou Data Engineer com conhecimentos em modelação de dados&nbsp;para se juntar à nossa equipa.</p>\n<p>O Data Engineer será responsável por:</p>\n<p></p>\n<p><strong><strong>Responsabilidades:</strong></strong><br>\n</p><ul><li>Melhorar o desempenho da recolha de dados de máquinas industriais, no código de framework, para que este seja mais rápido e eficaz.</li><li>Trabalhar na arquitetura de base de dados existente para melhorar o processamento de grandes volumes de dados e fluxos de ETL.</li><li>Desenvolver pipelines de ingestão para recolher dados de diversas fontes, como bases de dados externas, APIs e outros ficheiros.</li><li>Sugerir novas ideais de como melhorar a base de dados e criar soluções para limpar, filtrar e preparar dados para análise do cliente.</li><li>Implementar soluções de armazenamento que suportem grandes volumes de dados relacionais (e não relacionais) de forma segura.</li></ul>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios:</strong></strong><br>\n</p><ul><li>Grau académica a nível de Licenciatura, preferencialmente em Engenharia Informática, Tecnologia de Informação ou similar.&nbsp;</li><li>Experiência de +1 ano como Database Engineer ou&nbsp;Data Engineer&nbsp;preferencialmente na modelação de dados.</li><li>Experiência em SGBD (MySQL, PostgreSQL, Oracle, Microsoft SQL Server, ou outro).</li><li>Sólida compreensão na modelação de dados e normalização.</li><li>Desenho, implementação e otimização de bases de dados (relacionais e não relacionais) para melhor adequação ao projeto.</li><li>Conhecimentos com base de dados como NoSQL ou MongoDB será benéfico</li><li>Conhecimentos em programação como C, C++, C#, Python ou Java.</li><li>Autonomia de apreender novos conhecimentos e identificar melhores estratégias.</li></ul>","country":"Portugal","state":"","city":"Ilhavo","address":"","zipcode":"","location_display":"Ilhavo, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716591,"hash":"L576X9XR","position_name":"DBA - PL","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Administrador de Banco de Dados (DBA) Pleno desempenha um papel crítico na gestão eficiente e segura dos sistemas de banco de dados da empresa. Este profissional lidera iniciativas para garantir a integridade, confiabilidade e desempenho dos bancos de dados, bem como colabora com as equipes de desenvolvimento e infraestrutura para otimizar o acesso e uso dos dados.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Administração de Bancos de Dados: Gerenciar a instalação, configuração, atualização e manutenção contínua de sistemas de gerenciamento de banco de dados (DBMS).</p>\n<p>Otimização de Desempenho: Identificar e implementar estratégias para otimizar o desempenho dos bancos de dados, incluindo índices, particionamento e ajustes de consulta.</p>\n<p>Backup e Recuperação: Desenvolver e implementar planos de backup eficazes, além de garantir a prontidão para a recuperação em caso de falhas.</p>\n<p>Segurança do Banco de Dados: Implementar políticas e práticas de segurança para proteger os dados, incluindo controle de acesso, criptografia e auditorias.</p>\n<p>Monitoramento e Diagnóstico: Utilizar ferramentas de monitoramento para identificar problemas potenciais e diagnosticar questões relacionadas ao desempenho dos bancos de dados.</p>\n<p>Colaboração com Desenvolvimento: Trabalhar em estreita colaboração com as equipes de desenvolvimento para entender requisitos de dados, otimizar esquemas e garantir a eficácia das consultas.</p>\n<p>Gestão de Mudanças: Coordenar e implementar alterações no esquema do banco de dados, mantendo a integridade e a consistência dos dados.</p>\n<p>Atualizações de Software: Manter-se atualizado sobre as atualizações e patches do DBMS, aplicando-os de acordo com as melhores práticas.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Ciência da Computação, Engenharia de Computação, ou áreas relacionadas.</p>\n<p>Experiência substancial como DBA, preferencialmente em ambientes corporativos, mais de 5 anos.</p>\n<p>Conhecimento profundo em sistemas de gerenciamento de banco de dados, como Oracle, MySQL, SQL Server, PostgreSQL, etc.</p>\n<p>Experiência em otimização de desempenho, segurança e recuperação de desastres.</p>\n<p>Habilidade para diagnosticar e resolver problemas complexos de banco de dados.</p>\n<p>Fortes habilidades de comunicação e colaboração com outras equipes.</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Presencial: Remoto (Com visitas esporádicas no cliente) </li><li>Contratação PJ</li></ul>\n<p></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1929109,"hash":"L763YV6X","position_name":"Desenvolvedor Back End - Java Pl/Sr","description":"<p>Nosso cliente é ﻿um dos principais players do agronegócio brasileiro, oferecendo produtos e serviços de alta qualidade e com uma equipe qualificada para atender as necessidades dos produtores rurais em qualquer uma de suas 30 filiais, com presença em 6 estados.</p>\n<p><strong>Responsabilidades e Tarefas da Função﻿</strong></p>\n<ul>\n<li>Desenvolver e manter API's robustas, escaláveis e seguras usando Java;</li>\n<li>Colaborar com a equipe de front-end para garantir a integração perfeita entre as interfaces e o back-end;</li>\n<li>Implementar e otimizar bancos de dados para garantir alto desempenho e confiabilidade;</li>\n<li>Escrever código limpo, documentado e testável, seguindo as melhores práticas de desenvolvimento;</li>\n<li>Realizar revisões de código e garantir a qualidade do software através de testes rigorosos;</li>\n<li>Identificar e resolver problemas técnicos de forma eficiente e proativa;</li>\n<li>Manter-se atualizado com as tendências e tecnologias emergentes no campo de desenvolvimento back-end;</li>\n<li>Participar ativamente de reuniões e colaborar com outros membros da equipe para alcançar objetivos comuns.</li>\n</ul>\n<p><strong>Requisitos Obrigatórios﻿</strong></p>\n<ul>\n<li>Experiência comprovada como desenvolvedor back-end, preferencialmente com foco em Java;</li>\n<li>Profundo conhecimento em Spring Boot, JPA, Hibernate e RESTful API's;</li>\n<li>Experiência com bancos de dados relacionais, como MySQL ou PostgreSQL;</li>\n<li>Familiaridade com ferramentas de controle de versão, como Git;</li>\n<li>Capacidade comprovada de traduzir requisitos de design e negócios em código de alta qualidade;</li>\n<li>Excelentes habilidades de comunicação e trabalho em equipe;</li>\n<li>Formação acadêmica em Ciência da Computação, Engenharia de Software ou área relacionada (desejável, mas não obrigatória).﻿</li>\n</ul>\n<p><strong>Requisitos Complementares</strong></p>\n<ul>\n<li>Experiência com frameworks de micros erviços, como Spring Cloud;</li>\n<li>Conhecimento de ferramentas de monitoramento e observabilidade, como Prometheus e Grafana;</li>\n<li>Experiência com Docker e Kubernetes;</li>\n<li>Inglês (desejável não mandatário);</li>\n<li>Perfil hands on;</li>\n<li>Trabalho em equipe;</li>\n<li>Resolução de problemas;</li>\n<li>Adaptabilidade;</li>\n<li>Pensamento crítico;</li>\n<li>Gerenciamento de tempo;</li>\n<li>Empatia;</li>\n<li>Resiliência;</li>\n<li>Autoaprendizado;</li>\n<li>Criatividade;</li>\n<li>Ética profissional.<br>\n﻿<br>\n﻿﻿<strong>Informações Adicionais</strong>:</li>\n<ul>\n<li>Contratação: PJ.</li>\n<li>Remoto</li>\n</ul>\n</ul>","country":"Brazil","state":"","city":"Mato Grosso","address":"","zipcode":"","location_display":"Mato Grosso, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1769923,"hash":"L963X436","position_name":"Desenvolvedor Backend .NET  Banco de Talentos","description":"<p></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Junte-se a família PTC Group!</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje.</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos.</font></font></p>\n<p></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função:</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Atuar em time Scrum com foco principal em desenvolvimento C# .net;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Entender as necessidades do cliente;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Auxiliar na definição dos requisitos para criação e manutenção de sistemas/produtos;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Participar ativamente do desenho das soluções.</font></font></li></ul>\n<p></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos:</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência solida na prática no desenvolvimento de aplicações usando a plataforma .NET e a linguagem C#;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência com o ciclo de vida completo de desenvolvimento de software, desde a concepção até a implementação e manutenção;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Profundo conhecimento em C# e .NET Framework/.NET Core;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento aprofundado dos conceitos e práticas relacionadas a APIs, com experiência em desenvolvimento e integração de serviços RESTful e SOAP;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Expertise em Razor, uma tecnologia utilizada para criação de páginas web dinâmicas com o ASP.NET Core;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Proficiência no uso do Bootstrap para desenvolvimento de interfaces responsivas e visualmente atrativas;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência sólida com Docker, incluindo criação, gerenciamento e orquestração de contêineres para garantir a portabilidade e escalabilidade de aplicações;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento sólido em design de software e princípios de arquitetura;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Habilidade para projetar e desenvolver arquiteturas de software escaláveis e eficientes;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento em padrões de design, como MVC, MVVM, e outros padrões arquiteturais;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência em desenvolvimento web utilizando ASP.NET, ASP.NET Core, e tecnologias relacionadas;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Competência em design e otimização de bancos de dados usando SQL Server, Entity Framework ou outras tecnologias de acesso a dados;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento de JavaScript, HTML, CSS e frameworks front-end como Angular ou React;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Habilidade para colaborar em equipes ágeis usando metodologias como Scrum ou Kanban;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Consciência e prática de boas práticas de segurança no desenvolvimento de software;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Boas habilidades de comunicação para colaborar efetivamente com outros membros da equipe, clientes e stakeholders.</font></font></li></ul>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933690,"hash":"L4YW8X65","position_name":"Desenvolvedor Backend Node e Python (Lambda)","description":"<p></p>\n<p><strong>Como será o seu dia a dia:</strong><br>\n- Validação de estória e testes unitários nas tecnologias mencionadas;<br>\n- Participar das definições técnicas junto ao time técnico (arquiteto solução e desenvolvedores)<br>\n- Garantir qualidade e boas práticas de código de acordo com os padrões estabelecidos- Planejar e suportar as implantações e também o acompanhamento pós-implantação;<br>\n- Definir e garantir os requisitos não funcionais das aplicações (exemplo certificação técnica, SONAR e testes automatizados);<br>\n- Zelar pela esteira DEVOPS e monitoramento das aplicações nos ambientes teste, homologação e produção.<br><br></p>\n<p><strong>Qualificações necessárias:</strong></p>\n<p>-  Desenvolvimento AWS Lambda (node.js e python)<br>\n- Jenkins e Git<br>\n- Metodologia Ágil / Scrum<br>\n- Práticas DevSecOps<br>\n- Uso de APIs públicas e protegidas via JWT</p>\n<p>﻿<strong>Informações adicionais:<br>﻿</strong>Contratação:&nbsp;PJ<br>﻿Modelo de trabalho: Remoto&nbsp;</p>","country":"Brazil","state":"State of São Paulo","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716631,"hash":"L576X8V3","position_name":"Desenvolvedor de Software EMB/TR - PL","description":"<p>(redigir parágrafo sobre o cliente - sem mencionar o seu nome)<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br>\n</p>\n<p>O Desenvolvedor de Software Embarcado e Tempo Real Pleno desempenha um papel essencial na equipe de desenvolvimento, contribuindo para o design, implementação e manutenção de sistemas embarcados. Este profissional possui experiência sólida em desenvolvimento de software embarcado e em tempo real, participando ativamente em projetos críticos para a empresa.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Desenvolvimento de Software Embarcado: Participar do design e implementação de software embarcado para sistemas críticos.</p>\n<p>Desenvolvimento em Tempo Real: Projetar e implementar sistemas de software em tempo real para atender aos requisitos de performance e tempo de resposta em ambientes críticos.</p>\n<p>Desenvolvimento para Ambientes Computacionais Diversos: desenvolvimento de software para execução sobre sistemas operacionais distintos, como Windows, Linux, e RTOSs, para execução sobre diversos processadores como x86, ARM, Raspberry, dentre outros</p>\n<p>Otimização de Código: Identificar e implementar otimizações de código para garantir eficiência e baixo consumo de recursos em ambientes embarcados.</p>\n<p>Integração com Hardware: Colaborar com engenheiros de hardware para garantir a integração eficaz entre software e hardware em sistemas embarcados.</p>\n<p>Testes e Depuração: Realizar testes unitários e participar ativamente da depuração de sistemas embarcados.</p>\n<p>Documentação Técnica: Elaborar documentação técnica detalhada para o software desenvolvido, incluindo especificações e manuais.</p>\n<p>Colaboração com Equipes Multidisciplinares: Trabalhar em conjunto com equipes multidisciplinares, incluindo hardware, firmware e outras equipes de desenvolvimento.</p>\n<p>Atualizações e Manutenção: Participar de atualizações e manutenção contínua de software embarcado, garantindo sua confiabilidade e segurança.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Engenharia Computação</p>\n<p>Experiência de mais de 5 anos em desenvolvimento de software embarcado e em tempo real.</p>\n<p>Conhecimento em linguagens de programação de baixo nível, como C ou C++.</p>\n<p>Experiência em otimização de código e desenvolvimento para ambientes com recursos limitados.</p>\n<p>Familiaridade com padrões de comunicação de dados, em tempo real ou não, como CAN, MQTT, ou OPC UA, etc.</p>\n<p>Habilidade para trabalhar de forma colaborativa em projetos multidisciplinares.</p>\n<p>Boas habilidades de documentação e comunicação técnica.</p>\n<p><strong><br></strong></p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Híbrido em São José dos Campos/SP</li><li>Contratação PJ</li></ul>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716626,"hash":"QW9WV8X6","position_name":"Desenvolvedor de Software EMB/TR - SR","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Desenvolvedor de Software Embarcado e Tempo Real Sênior desempenha um papel estratégico na equipe de desenvolvimento, liderando e contribuindo para projetos complexos de sistemas embarcados. Este profissional possui um profundo conhecimento em desenvolvimento de software embarcado e em tempo real, liderando iniciativas para garantir a eficiência e confiabilidade de sistemas críticos.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Arquitetura de Software Embarcado: Liderar o design e a arquitetura de sistemas embarcados, garantindo a eficiência, confiabilidade e integridade dos componentes de software.</p>\n<p>Desenvolvimento em Tempo Real: Projetar e implementar sistemas de software em tempo real para atender aos requisitos de performance e tempo de resposta em ambientes críticos.</p>\n<p>Desenvolvimento para Ambientes Computacionais Diversos: desenvolvimento de software para execução sobre sistemas operacionais distintos, como Windows, Linux, e RTOSs, para execução sobre diversos processadores como x86, ARM, Raspberry, dentre outros.</p>\n<p>Otimização de Desempenho: Identificar e implementar estratégias para otimizar o desempenho de sistemas embarcados, garantindo eficiência energética e recursos limitados.</p>\n<p>Integração com Hardware: Colaborar com engenheiros de hardware para garantir a integração eficaz entre software e hardware em sistemas embarcados.</p>\n<p>Colaboração com Equipes Multidisciplinares: Trabalhar em estreita colaboração com engenheiros de hardware, analistas de sistemas e outros desenvolvedores para garantir a integração eficaz de software e hardware.</p>\n<p>Liderança Técnica: Fornecer liderança técnica para a equipe, orientando desenvolvedores juniores e participando ativamente das tomadas de decisão estratégicas.</p>\n<p>Testes e Validação: Desenvolver e executar testes rigorosos para validar a funcionalidade e a segurança de sistemas embarcados.</p>\n<p>Melhoria Contínua: Contribuir para a melhoria contínua dos processos de desenvolvimento de software embarcado, implementando práticas inovadoras e adotando novas tecnologias.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Engenharia de Computação</p>\n<p>Experiência de mais de 10 anos em desenvolvimento de software embarcado e em tempo real.</p>\n<p>Conhecimento profundo em linguagens como C e C++ para ambientes embarcados.</p>\n<p>Experiência em arquitetura de sistemas embarcados e otimização de código.</p>\n<p>Familiaridade com padrões de comunicação de dados, em tempo real ou não, como CAN, MQTT, ou OPC UA, etc.</p>\n<p>Habilidade para liderar equipes e projetos complexos.</p>\n<p>Fortes conhecimentos em microeletrônica</p>\n<p>Excelentes habilidades de comunicação e trabalho em equipe.</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Híbrido em São José dos Campos/SP&nbsp;</li><li>Contratação PJ</li></ul>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1929086,"hash":"QWYVX486","position_name":"Desenvolvedor Front - React Pl/Sr","description":"<p>Nosso cliente é ﻿um dos principais players do agronegócio brasileiro, oferecendo produtos e serviços de alta qualidade e com uma equipe qualificada para atender as necessidades dos produtores rurais em qualquer uma de suas 30 filiais, com presença em 6 estados.</p>\n<p><strong>Responsabilidades e Tarefas da Função﻿﻿</strong></p>\n<ul>\n<li>Desenvolver interfaces de usuário responsivas e intuitivas para aplicativos web e móveis utilizando React;</li>\n<li>Colaborar com designers e desenvolvedores back-end para traduzir requisitos de negócios e designs em soluções técnicas viáveis;</li>\n<li>Utilizar as melhores práticas de desenvolvimento front-end para garantir desempenho, escalabilidade e segurança;</li>\n<li>Manter-se atualizado com as tendências e tecnologias emergentes no campo do desenvolvimento front-end, incluindo o aprendizado de NestJS;</li>\n<li>Realizar revisões de código e garantir a qualidade do software através de testes rigorosos;</li>\n<li>Identificar e resolver problemas técnicos e de usabilidade durante todo o ciclo de vida do projeto;</li>\n<li>Participar ativamente de reuniões e colaborar com outros membros da equipe para alcançar objetivos comuns.</li>\n</ul>\n<p><strong>Requisitos Obrigatórios﻿﻿</strong></p>\n<ul>\n<li>Experiência comprovada como desenvolvedor front-end, preferencialmente com foco em React e Javascript;</li>\n<li>Sólido conhecimento de conceitos como HTML, CSS, Javascript (ES6+), e frameworks como React e Redux;</li>\n<li>Experiência com ferramentas de controle de versão, como Git;</li>\n<li>Familiaridade com princípios de design responsivo e acessibilidade;</li>\n<li>Capacidade comprovada de traduzir requisitos de design e negócios em código limpo, reutilizável e bem documentado;</li>\n<li>Excelentes habilidades de comunicação e trabalho em equipe;</li>\n<li>Formação acadêmica em Ciência da Computação, Engenharia de Software ou área relacionada (desejável, mas não obrigatória).</li>\n</ul>\n<p><strong>Requisitos Complementares﻿</strong></p>\n<ul>\n<li>Experiência com NextJS (desejável);</li>\n<li>Conhecimento de ferramentas de build e otimização, como Webpack e Babel;</li>\n<li>Experiência com testes unitários e de integração;</li>\n<li>Inglês (desejável não mandatário);</li>\n<li>Perfil hands-on;</li>\n<li>Trabalho em equipe;</li>\n<li>Resolução de problemas;</li>\n<li>Adaptabilidade;</li>\n<li>Pensamento crítico;</li>\n<li>Gerenciamento de tempo;</li>\n<li>Empatia;</li>\n<li>Resiliência;</li>\n<li>Auto aprendizado;</li>\n<li>Criatividade;</li>\n<li>Ética profissional.</li>\n</ul>\n<p></p>\n<p><strong>Informações Adicionais</strong>:</p>\n<ul>\n<li>Contratação: Prestador de Serviços (PJ)</li>\n<li>Modelo de Trabalho: Remoto</li>\n</ul>","country":"Brazil","state":"","city":"Mato Grosso","address":"","zipcode":"","location_display":"Mato Grosso, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1937033,"hash":"L763VR65","position_name":"Desenvolvedor Mobile React Native","description":"<p>Nosso cliente é uma multinacional brasileira com 45 anos de atuações, sediada em Cuiabá, atualmente é uma das empresas líderes do Agronegócio na América Latina e com atuação em 7 países. Além de trading a companhia tem ramificação nas áreas de sementes, transporte fluvial, beneficiamento de soja, geração de energia e na área financeira.</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li>Desenvolver e manter aplicativos móveis utilizando React Native;</li><li>Colaborar com designers e outros membros da equipe para entender requisitos de negócios e traduzi-los em soluções técnicas;</li><li>Garantir a qualidade do código, incluindo testes unitários e integração contínua;</li><li>Otimizar o desempenho dos aplicativos para dispositivos móveis;</li><li>Investigar e resolver problemas, bugs e problemas de desempenho;</li><li>Ficar atualizado(a) com as melhores práticas de desenvolvimento móvel e tendências da indústria.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Experiência comprovada no desenvolvimento de aplicativos móveis usando React Native;</li><li>Sólida compreensão de JavaScript, incluindo ES6/ES7;</li><li>Familiaridade com princípios de design de interface de usuário e experiência do usuário;</li><li>Conhecimento de arquiteturas de aplicativos móveis, padrões de design e melhores práticas;</li><li>Experiência com ferramentas de controle de versão, como Git;</li><li>Capacidade de trabalhar de forma independente e em equipe, com forte habilidade de comunicação;</li><li>Graduação em Ciência da Computação, Engenharia de Software, ou área relacionada (ou experiência equivalente).</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong></p>\n<ul><li>Experiência prévia com desenvolvimento nativo para iOS e/ou Android;</li><li>Conhecimento de ferramentas de CI/CD;</li><li>Familiaridade com GraphQL e APIs RESTful;</li><li>Experiência com metodologias ágeis, como Scrum ou Kanban.</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1658215,"hash":"QX73R343","position_name":"Desenvolvedor .Net","description":"<p>Nosso cliente é uma multinacional brasileira com 45 anos de atuações, sediada em Cuiabá, atualmente é uma das empresas líderes do Agronegócio na América Latina e com atuação em 7 países. Além de trading a companhia tem ramificação nas áreas de sementes, transporte fluvial, beneficiamento de soja, geração de energia e na área financeira.<br></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿VAGA:&nbsp;Analista de Desenvolvimento&nbsp;.NET&nbsp;</strong></strong><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<ul><li>Experiência solida na&nbsp;prática no desenvolvimento de aplicações usando a plataforma .NET e a linguagem C#.</li><li>Experiência com o ciclo de vida completo de desenvolvimento de software, desde a concepção até a implementação e manutenção.</li><li>Profundo conhecimento em C# e .NET Framework/.NET Core.</li><li>Conhecimento aprofundado dos conceitos e práticas relacionadas a APIs, com experiência em desenvolvimento e integração de serviços RESTful e SOAP.</li><li>Expertise em Razor, uma tecnologia utilizada para criação de páginas web dinâmicas com o ASP.NET Core.</li><li>Proficiência no uso do Bootstrap para desenvolvimento de interfaces responsivas e visualmente atrativas.</li><li>Experiência sólida com Docker, incluindo criação, gerenciamento e orquestração de contêineres para garantir a portabilidade e escalabilidade de aplicações.</li><li>﻿Conhecimento sólido em design de software e princípios de arquitetura.</li><li>Habilidade para projetar e desenvolver arquiteturas de software escaláveis e eficientes.</li><li>Conhecimento em padrões de design, como MVC, MVVM, e outros padrões arquiteturais.</li><li>Experiência em desenvolvimento web utilizando ASP.NET, ASP.NET Core, e tecnologias relacionadas.</li><li>Competência em design e otimização de bancos de dados usando SQL Server, Entity Framework ou outras tecnologias de acesso a dados.</li><li><span style=\"font-size: 1em;\">Conhecimento de JavaScript, HTML, CSS e frameworks front-end como Angular ou React.</span></li><li>Habilidade para colaborar em equipes ágeis usando metodologias como Scrum ou Kanban.</li><li>Consciência e prática de boas práticas de segurança no desenvolvimento de software.</li><li>Boas habilidades de comunicação para colaborar efetivamente com outros membros da equipe, clientes e stakeholders.</li></ul>\n<p><br><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<ul><li>Modelo de Trabalho: Remoto</li><li>Contratação: Prestador de Serviços</li><li>Senioridade: Sênior</li></ul><p><br></p><p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:54 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=9","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=7","results":[{"id":1938227,"hash":"QX3W83XR","position_name":"Cost Serial Life Cost Performance","description":"<p></p>\n<p>Join the PTC Group family <br><br>We are always looking for talents who have a passion for progress, innovation, and curiosity to tackle the challenges that affect our society today. <br><br>We are a multinational Engineering &amp; IT company, being reliable partners of major global companies. Focused on the future, we are driven by the pursuit of excellence in everything we do. </p>\n<p><strong><strong>Responsibilities and Tasks of the Job<br>﻿<br>﻿﻿Cost Serial Life Cost Performance / Car Line A-B Segment.</strong></strong><br></p>\n<ul><li>VO Carline Pilot, for Palomar plant models (CMP family). Phisycal presence in Palomar plant at least 2 days a week</li><li>Tasks:<ul><li>ensure implementation and financial accounting of cost evolution/saving</li><li>enhance idea generation</li><li>promote efficiency       </li></ul></li></ul>\n<ul><li>Required location: Argentina, close to Stellantis Palomar Plant</li></ul>\n<p><br></p>\n<p><strong><strong><strong>Mandatory Skills</strong></strong></strong><br>Experience in design, release or processing role; or other credentials <br>in combination with relevant experience in developing variable and/or <br>tooling costs for automotive components<br> Automotive knowledge of production methods and development <br>processes in the vehicle sector, focus on metal sheet stamping and <br>body in white manufacturing processes<br> Automotive components basic economical knowledge (cost factors, <br>cost analysis methods, etc.)<br> Detail oriented with ability to manage multiple programs and cost <br>details simultaneously<br> Solid leadership, interpersonal and communication skills with English <br>as official language for communication (written and oral</p>\n<p><strong><strong>Complementary Skills</strong></strong><br>Proficiency in NX and Teamcenter.<br> Activity based costing experience or experience in cost model <br>development</p>\n<p><strong><strong>What we offer</strong></strong><br>(write)</p>","country":"Argentina","state":"Buenos Aires Province","city":"Palomar","address":"","zipcode":"","location_display":"Palomar, Buenos Aires Province, Argentina","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1948314,"hash":"QWYV7879","position_name":"Database Engineer","description":"<p></p>\n<p>A PTC Group está a recrutar um Database Engineer ou Data Engineer com conhecimentos em modelação de dados&nbsp;para se juntar à nossa equipa.</p>\n<p>O Data Engineer será responsável por:</p>\n<p></p>\n<p><strong><strong>Responsabilidades:</strong></strong><br>\n</p><ul><li>Melhorar o desempenho da recolha de dados de máquinas industriais, no código de framework, para que este seja mais rápido e eficaz.</li><li>Trabalhar na arquitetura de base de dados existente para melhorar o processamento de grandes volumes de dados e fluxos de ETL.</li><li>Desenvolver pipelines de ingestão para recolher dados de diversas fontes, como bases de dados externas, APIs e outros ficheiros.</li><li>Sugerir novas ideais de como melhorar a base de dados e criar soluções para limpar, filtrar e preparar dados para análise do cliente.</li><li>Implementar soluções de armazenamento que suportem grandes volumes de dados relacionais (e não relacionais) de forma segura.</li></ul>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios:</strong></strong><br>\n</p><ul><li>Grau académica a nível de Licenciatura, preferencialmente em Engenharia Informática, Tecnologia de Informação ou similar.&nbsp;</li><li>Experiência de +1 ano como Database Engineer ou&nbsp;Data Engineer&nbsp;preferencialmente na modelação de dados.</li><li>Experiência em SGBD (MySQL, PostgreSQL, Oracle, Microsoft SQL Server, ou outro).</li><li>Sólida compreensão na modelação de dados e normalização.</li><li>Desenho, implementação e otimização de bases de dados (relacionais e não relacionais) para melhor adequação ao projeto.</li><li>Conhecimentos com base de dados como NoSQL ou MongoDB será benéfico</li><li>Conhecimentos em programação como C, C++, C#, Python ou Java.</li><li>Autonomia de apreender novos conhecimentos e identificar melhores estratégias.</li></ul>","country":"Portugal","state":"","city":"Ilhavo","address":"","zipcode":"","location_display":"Ilhavo, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965259,"hash":"L96W5466","position_name":"Data Engineer (Financial Sector)","description":"<p><strong>Job position:&nbsp;Data Engineer for Financial Sector<br><br>Location: ﻿Hybrid work from Madrid (3 times per week at the client's office)</strong></p>\n<p></p>\n<p>PTC Group is recruiting for a digital consultancy and technology services provider that offers edge-to-core solutions to help organizations achieve the full potential of AI-driven digital transformation. Utilizing a technology-unified operating model for cloud, data, and IoT, this company delivers end-to-end value creation for clients through innovation in digital engineering, implementation services, products, and solutions.﻿</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsibilities and Tasks of the Job</strong></strong></p>\n<ul><li><strong><strong></strong></strong>Refinement / Envisoning of technical solutions to address business</li><li>Requirements in light of the client Data Standards / Framework</li><li>Implementation of Data Pipelines / Data Processes / APIs within the Data Platform Technical Stack</li><li>Responsible for Development Environment Testing providing base evidence of results</li><li>Support QA Engineers during SIT Testing Phase on Testing environment and responsible for Production deployment</li><li>Support the Team on solving Production environment issues with existing Data Pipelines / REST APIs</li><li>Main responsible on the Documentation effort of the technical solutions implemented (at User Story level / Data Catalog level)﻿</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Mandatory   Skills</strong></p>\n<ul><li>﻿5+ years working on Data Engineering</li><li>Exposure to Data projects within the domains of Accounting, Financial Performance Management, Financial Planning &amp; Analysis</li><li>Sound   understanding of Data Architecture / Data Modelling</li><li>Python   Programming for Data (Functional approach)</li><li>Relational Database / SQL Experience</li><li>Previous exposure to REST APIs ( for Data Pipelines / ETL )</li><li>Previous exposure to SOAP APIs ( for Data Pipelines / ETL )</li><li>Git   &amp; CI/CD (multi-branch approach)</li><li>Fluent   in English (Writing,&nbsp;Reading, Speaking)</li><li>Experience on working within Agile Teams</li><li>Ability to articulate conversations with Business Stakeholders beyond   technical level discussion of the user stories</li><li>Able   to design technical solutions to address business requirements</li></ul>","country":"Spain","state":"","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965252,"hash":"QY4YXR4V","position_name":"DataOps Engineer (Financial Sector)","description":"<p><strong>Job position: DataOps Engineer for Financial Sector<br><br>Location: ﻿Remote Work from Portugal (with the possibility to travel to Madrid on request)</strong></p>\n<p></p>\n<p>PTC Group is recruiting for a digital consultancy and technology services provider that offers edge-to-core solutions to help organizations achieve the full potential of AI-driven digital transformation. Utilizing a technology-unified operating model for cloud, data, and IoT, this company delivers end-to-end value creation for clients through innovation in digital engineering, implementation services, products, and solutions.﻿</p>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Responsibilities and Tasks of the Job</strong></strong></p>\n<ul><li>Must have demonstrated skills and experience within data delivery, ETL/ELT, data management, strong communications, and analytical mindset.</li><li>Develop ETL/ELT solutions using AWS cloud services, Databricks</li><li>Identify, design, and implement internal process improvements: automating manual processes, optimizing data delivery, redesigning infrastructure for greater scalability</li><li>Modify existing pipelines in order to achieve automation where possible and accommodate changes in the data structure</li><li>Maintain platform performing regular tasks such as user management and audit, resource utilization, alerts monitoring, and code reviews.﻿</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Mandatory   Skills:</strong></p>\n<p> </p>\n<p> </p>\n<ul><li>  The   DataOps Engineer provides data engineers with guidance and design support   around workflows and information pipelines and flows, code reviews, and all   new processes and workflows around utilizing data.</li><li>Design, build, and optimize data pipelines to extract data from different   sources and applications</li><li>Work   closely with the Data Engineers and Data Analysts in building, testing, and   production data extraction, transformation and reporting requirements</li><li>Support Data Engineers and Data Analysts</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716591,"hash":"L576X9XR","position_name":"DBA - PL","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Administrador de Banco de Dados (DBA) Pleno desempenha um papel crítico na gestão eficiente e segura dos sistemas de banco de dados da empresa. Este profissional lidera iniciativas para garantir a integridade, confiabilidade e desempenho dos bancos de dados, bem como colabora com as equipes de desenvolvimento e infraestrutura para otimizar o acesso e uso dos dados.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Administração de Bancos de Dados: Gerenciar a instalação, configuração, atualização e manutenção contínua de sistemas de gerenciamento de banco de dados (DBMS).</p>\n<p>Otimização de Desempenho: Identificar e implementar estratégias para otimizar o desempenho dos bancos de dados, incluindo índices, particionamento e ajustes de consulta.</p>\n<p>Backup e Recuperação: Desenvolver e implementar planos de backup eficazes, além de garantir a prontidão para a recuperação em caso de falhas.</p>\n<p>Segurança do Banco de Dados: Implementar políticas e práticas de segurança para proteger os dados, incluindo controle de acesso, criptografia e auditorias.</p>\n<p>Monitoramento e Diagnóstico: Utilizar ferramentas de monitoramento para identificar problemas potenciais e diagnosticar questões relacionadas ao desempenho dos bancos de dados.</p>\n<p>Colaboração com Desenvolvimento: Trabalhar em estreita colaboração com as equipes de desenvolvimento para entender requisitos de dados, otimizar esquemas e garantir a eficácia das consultas.</p>\n<p>Gestão de Mudanças: Coordenar e implementar alterações no esquema do banco de dados, mantendo a integridade e a consistência dos dados.</p>\n<p>Atualizações de Software: Manter-se atualizado sobre as atualizações e patches do DBMS, aplicando-os de acordo com as melhores práticas.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Ciência da Computação, Engenharia de Computação, ou áreas relacionadas.</p>\n<p>Experiência substancial como DBA, preferencialmente em ambientes corporativos, mais de 5 anos.</p>\n<p>Conhecimento profundo em sistemas de gerenciamento de banco de dados, como Oracle, MySQL, SQL Server, PostgreSQL, etc.</p>\n<p>Experiência em otimização de desempenho, segurança e recuperação de desastres.</p>\n<p>Habilidade para diagnosticar e resolver problemas complexos de banco de dados.</p>\n<p>Fortes habilidades de comunicação e colaboração com outras equipes.</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Presencial: Remoto (Com visitas esporádicas no cliente) </li><li>Contratação PJ</li></ul>\n<p></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1929109,"hash":"L763YV6X","position_name":"Desenvolvedor Back End - Java Pl/Sr","description":"<p>Nosso cliente é ﻿um dos principais players do agronegócio brasileiro, oferecendo produtos e serviços de alta qualidade e com uma equipe qualificada para atender as necessidades dos produtores rurais em qualquer uma de suas 30 filiais, com presença em 6 estados.</p>\n<p><strong>Responsabilidades e Tarefas da Função﻿</strong></p>\n<ul>\n<li>Desenvolver e manter API's robustas, escaláveis e seguras usando Java;</li>\n<li>Colaborar com a equipe de front-end para garantir a integração perfeita entre as interfaces e o back-end;</li>\n<li>Implementar e otimizar bancos de dados para garantir alto desempenho e confiabilidade;</li>\n<li>Escrever código limpo, documentado e testável, seguindo as melhores práticas de desenvolvimento;</li>\n<li>Realizar revisões de código e garantir a qualidade do software através de testes rigorosos;</li>\n<li>Identificar e resolver problemas técnicos de forma eficiente e proativa;</li>\n<li>Manter-se atualizado com as tendências e tecnologias emergentes no campo de desenvolvimento back-end;</li>\n<li>Participar ativamente de reuniões e colaborar com outros membros da equipe para alcançar objetivos comuns.</li>\n</ul>\n<p><strong>Requisitos Obrigatórios﻿</strong></p>\n<ul>\n<li>Experiência comprovada como desenvolvedor back-end, preferencialmente com foco em Java;</li>\n<li>Profundo conhecimento em Spring Boot, JPA, Hibernate e RESTful API's;</li>\n<li>Experiência com bancos de dados relacionais, como MySQL ou PostgreSQL;</li>\n<li>Familiaridade com ferramentas de controle de versão, como Git;</li>\n<li>Capacidade comprovada de traduzir requisitos de design e negócios em código de alta qualidade;</li>\n<li>Excelentes habilidades de comunicação e trabalho em equipe;</li>\n<li>Formação acadêmica em Ciência da Computação, Engenharia de Software ou área relacionada (desejável, mas não obrigatória).﻿</li>\n</ul>\n<p><strong>Requisitos Complementares</strong></p>\n<ul>\n<li>Experiência com frameworks de micros erviços, como Spring Cloud;</li>\n<li>Conhecimento de ferramentas de monitoramento e observabilidade, como Prometheus e Grafana;</li>\n<li>Experiência com Docker e Kubernetes;</li>\n<li>Inglês (desejável não mandatário);</li>\n<li>Perfil hands on;</li>\n<li>Trabalho em equipe;</li>\n<li>Resolução de problemas;</li>\n<li>Adaptabilidade;</li>\n<li>Pensamento crítico;</li>\n<li>Gerenciamento de tempo;</li>\n<li>Empatia;</li>\n<li>Resiliência;</li>\n<li>Autoaprendizado;</li>\n<li>Criatividade;</li>\n<li>Ética profissional.<br>\n﻿<br>\n﻿﻿<strong>Informações Adicionais</strong>:</li>\n<ul>\n<li>Contratação: PJ.</li>\n<li>Remoto</li>\n</ul>\n</ul>","country":"Brazil","state":"","city":"Mato Grosso","address":"","zipcode":"","location_display":"Mato Grosso, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1769923,"hash":"L963X436","position_name":"Desenvolvedor Backend .NET  Banco de Talentos","description":"<p></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Junte-se a família PTC Group!</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje.</font></font></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos.</font></font></p>\n<p></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função:</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Atuar em time Scrum com foco principal em desenvolvimento C# .net;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Entender as necessidades do cliente;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Auxiliar na definição dos requisitos para criação e manutenção de sistemas/produtos;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Participar ativamente do desenho das soluções.</font></font></li></ul>\n<p></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos:</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência solida na prática no desenvolvimento de aplicações usando a plataforma .NET e a linguagem C#;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência com o ciclo de vida completo de desenvolvimento de software, desde a concepção até a implementação e manutenção;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Profundo conhecimento em C# e .NET Framework/.NET Core;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento aprofundado dos conceitos e práticas relacionadas a APIs, com experiência em desenvolvimento e integração de serviços RESTful e SOAP;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Expertise em Razor, uma tecnologia utilizada para criação de páginas web dinâmicas com o ASP.NET Core;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Proficiência no uso do Bootstrap para desenvolvimento de interfaces responsivas e visualmente atrativas;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência sólida com Docker, incluindo criação, gerenciamento e orquestração de contêineres para garantir a portabilidade e escalabilidade de aplicações;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento sólido em design de software e princípios de arquitetura;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Habilidade para projetar e desenvolver arquiteturas de software escaláveis e eficientes;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento em padrões de design, como MVC, MVVM, e outros padrões arquiteturais;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência em desenvolvimento web utilizando ASP.NET, ASP.NET Core, e tecnologias relacionadas;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Competência em design e otimização de bancos de dados usando SQL Server, Entity Framework ou outras tecnologias de acesso a dados;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento de JavaScript, HTML, CSS e frameworks front-end como Angular ou React;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Habilidade para colaborar em equipes ágeis usando metodologias como Scrum ou Kanban;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Consciência e prática de boas práticas de segurança no desenvolvimento de software;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Boas habilidades de comunicação para colaborar efetivamente com outros membros da equipe, clientes e stakeholders.</font></font></li></ul>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933690,"hash":"L4YW8X65","position_name":"Desenvolvedor Backend Node e Python (Lambda)","description":"<p></p>\n<p><strong>Como será o seu dia a dia:</strong><br>\n- Validação de estória e testes unitários nas tecnologias mencionadas;<br>\n- Participar das definições técnicas junto ao time técnico (arquiteto solução e desenvolvedores)<br>\n- Garantir qualidade e boas práticas de código de acordo com os padrões estabelecidos- Planejar e suportar as implantações e também o acompanhamento pós-implantação;<br>\n- Definir e garantir os requisitos não funcionais das aplicações (exemplo certificação técnica, SONAR e testes automatizados);<br>\n- Zelar pela esteira DEVOPS e monitoramento das aplicações nos ambientes teste, homologação e produção.<br><br></p>\n<p><strong>Qualificações necessárias:</strong></p>\n<p>-  Desenvolvimento AWS Lambda (node.js e python)<br>\n- Jenkins e Git<br>\n- Metodologia Ágil / Scrum<br>\n- Práticas DevSecOps<br>\n- Uso de APIs públicas e protegidas via JWT</p>\n<p>﻿<strong>Informações adicionais:<br>﻿</strong>Contratação:&nbsp;PJ<br>﻿Modelo de trabalho: Remoto&nbsp;</p>","country":"Brazil","state":"State of São Paulo","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, State of São Paulo, Brazil","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716631,"hash":"L576X8V3","position_name":"Desenvolvedor de Software EMB/TR - PL","description":"<p>(redigir parágrafo sobre o cliente - sem mencionar o seu nome)<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br>\n</p>\n<p>O Desenvolvedor de Software Embarcado e Tempo Real Pleno desempenha um papel essencial na equipe de desenvolvimento, contribuindo para o design, implementação e manutenção de sistemas embarcados. Este profissional possui experiência sólida em desenvolvimento de software embarcado e em tempo real, participando ativamente em projetos críticos para a empresa.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Desenvolvimento de Software Embarcado: Participar do design e implementação de software embarcado para sistemas críticos.</p>\n<p>Desenvolvimento em Tempo Real: Projetar e implementar sistemas de software em tempo real para atender aos requisitos de performance e tempo de resposta em ambientes críticos.</p>\n<p>Desenvolvimento para Ambientes Computacionais Diversos: desenvolvimento de software para execução sobre sistemas operacionais distintos, como Windows, Linux, e RTOSs, para execução sobre diversos processadores como x86, ARM, Raspberry, dentre outros</p>\n<p>Otimização de Código: Identificar e implementar otimizações de código para garantir eficiência e baixo consumo de recursos em ambientes embarcados.</p>\n<p>Integração com Hardware: Colaborar com engenheiros de hardware para garantir a integração eficaz entre software e hardware em sistemas embarcados.</p>\n<p>Testes e Depuração: Realizar testes unitários e participar ativamente da depuração de sistemas embarcados.</p>\n<p>Documentação Técnica: Elaborar documentação técnica detalhada para o software desenvolvido, incluindo especificações e manuais.</p>\n<p>Colaboração com Equipes Multidisciplinares: Trabalhar em conjunto com equipes multidisciplinares, incluindo hardware, firmware e outras equipes de desenvolvimento.</p>\n<p>Atualizações e Manutenção: Participar de atualizações e manutenção contínua de software embarcado, garantindo sua confiabilidade e segurança.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Engenharia Computação</p>\n<p>Experiência de mais de 5 anos em desenvolvimento de software embarcado e em tempo real.</p>\n<p>Conhecimento em linguagens de programação de baixo nível, como C ou C++.</p>\n<p>Experiência em otimização de código e desenvolvimento para ambientes com recursos limitados.</p>\n<p>Familiaridade com padrões de comunicação de dados, em tempo real ou não, como CAN, MQTT, ou OPC UA, etc.</p>\n<p>Habilidade para trabalhar de forma colaborativa em projetos multidisciplinares.</p>\n<p>Boas habilidades de documentação e comunicação técnica.</p>\n<p><strong><br></strong></p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Híbrido em São José dos Campos/SP</li><li>Contratação PJ</li></ul>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716626,"hash":"QW9WV8X6","position_name":"Desenvolvedor de Software EMB/TR - SR","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Desenvolvedor de Software Embarcado e Tempo Real Sênior desempenha um papel estratégico na equipe de desenvolvimento, liderando e contribuindo para projetos complexos de sistemas embarcados. Este profissional possui um profundo conhecimento em desenvolvimento de software embarcado e em tempo real, liderando iniciativas para garantir a eficiência e confiabilidade de sistemas críticos.</p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>\n</p>\n<p>Arquitetura de Software Embarcado: Liderar o design e a arquitetura de sistemas embarcados, garantindo a eficiência, confiabilidade e integridade dos componentes de software.</p>\n<p>Desenvolvimento em Tempo Real: Projetar e implementar sistemas de software em tempo real para atender aos requisitos de performance e tempo de resposta em ambientes críticos.</p>\n<p>Desenvolvimento para Ambientes Computacionais Diversos: desenvolvimento de software para execução sobre sistemas operacionais distintos, como Windows, Linux, e RTOSs, para execução sobre diversos processadores como x86, ARM, Raspberry, dentre outros.</p>\n<p>Otimização de Desempenho: Identificar e implementar estratégias para otimizar o desempenho de sistemas embarcados, garantindo eficiência energética e recursos limitados.</p>\n<p>Integração com Hardware: Colaborar com engenheiros de hardware para garantir a integração eficaz entre software e hardware em sistemas embarcados.</p>\n<p>Colaboração com Equipes Multidisciplinares: Trabalhar em estreita colaboração com engenheiros de hardware, analistas de sistemas e outros desenvolvedores para garantir a integração eficaz de software e hardware.</p>\n<p>Liderança Técnica: Fornecer liderança técnica para a equipe, orientando desenvolvedores juniores e participando ativamente das tomadas de decisão estratégicas.</p>\n<p>Testes e Validação: Desenvolver e executar testes rigorosos para validar a funcionalidade e a segurança de sistemas embarcados.</p>\n<p>Melhoria Contínua: Contribuir para a melhoria contínua dos processos de desenvolvimento de software embarcado, implementando práticas inovadoras e adotando novas tecnologias.</p>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n</p>\n<p>Formação em Engenharia de Computação</p>\n<p>Experiência de mais de 10 anos em desenvolvimento de software embarcado e em tempo real.</p>\n<p>Conhecimento profundo em linguagens como C e C++ para ambientes embarcados.</p>\n<p>Experiência em arquitetura de sistemas embarcados e otimização de código.</p>\n<p>Familiaridade com padrões de comunicação de dados, em tempo real ou não, como CAN, MQTT, ou OPC UA, etc.</p>\n<p>Habilidade para liderar equipes e projetos complexos.</p>\n<p>Fortes conhecimentos em microeletrônica</p>\n<p>Excelentes habilidades de comunicação e trabalho em equipe.</p>\n<p><strong>Informações Adicionais</strong>:<br></p>\n<ul><li>Híbrido em São José dos Campos/SP&nbsp;</li><li>Contratação PJ</li></ul>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:40 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=9
@@ -580,11 +580,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:55 GMT
+      - Tue, 30 Jul 2024 16:28:41 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '21996'
+      - '24668'
       Connection:
       - keep-alive
       Server:
@@ -605,8 +605,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=10","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=8","results":[{"id":1753061,"hash":"QVXW77W8","position_name":"Desenvolvedor .Net","description":"<p>Nosso cliente é uma multinacional brasileira com 45 anos de atuações, sediada em Cuiabá, atualmente é uma das empresas líderes do Agronegócio na América Latina e com atuação em 7 países. Além de trading a companhia tem ramificação nas áreas de sementes, transporte fluvial, beneficiamento de soja, geração de energia e na área financeira.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br>\n</p><ul><li>Experiência solida na prática no desenvolvimento de aplicações usando a plataforma .NET e a linguagem C#.</li><li>Experiência com o ciclo de vida completo de desenvolvimento de software, desde a concepção até a implementação e manutenção.</li><li>Profundo conhecimento em C# e .NET Framework/.NET Core.</li><li>Conhecimento aprofundado dos conceitos e práticas relacionadas a APIs, com experiência em desenvolvimento e integração de serviços RESTful e SOAP.</li><li>Expertise em Razor, uma tecnologia utilizada para criação de páginas web dinâmicas com o ASP.NET Core.</li><li>Proficiência no uso do Bootstrap para desenvolvimento de interfaces responsivas e visualmente atrativas.</li><li>Experiência sólida com Docker, incluindo criação, gerenciamento e orquestração de contêineres para garantir a portabilidade e escalabilidade de aplicações.</li><li>Conhecimento sólido em design de software e princípios de arquitetura.</li><li>Habilidade para projetar e desenvolver arquiteturas de software escaláveis e eficientes.</li><li>Conhecimento em padrões de design, como MVC, MVVM, e outros padrões arquiteturais.</li><li>Experiência em desenvolvimento web utilizando ASP.NET, ASP.NET Core, e tecnologias relacionadas.</li><li>Competência em design e otimização de bancos de dados usando SQL Server, Entity Framework ou outras tecnologias de acesso a dados.</li><li>Conhecimento de JavaScript, HTML, CSS e frameworks front-end como Angular ou React.</li><li>Habilidade para colaborar em equipes ágeis usando metodologias como Scrum ou Kanban.</li><li>Consciência e prática de boas práticas de segurança no desenvolvimento de software.</li><li>Boas habilidades de comunicação para colaborar efetivamente com outros membros da equipe, clientes e stakeholders.</li></ul>\n<p></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Complementares</strong></strong><br></p>\n<p>\n</p><ul><li>Modelo de Trabalho: Remoto</li><li>Contratação: Prestador de Serviços</li><li>Senioridade: Sênior</li></ul>\n<p><br></p>\n<p></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1715079,"hash":"L57647RR","position_name":"Desenvolvedor PHP","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\" _msttexthash=\"1135381\" _msthash=\"435\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p _msttexthash=\"1748799\" _msthash=\"316\">\n</p>\n<p _msttexthash=\"22423427\" _msthash=\"436\">Experiência em PHP, SQL, HTML, CSS e\nJavascript.Capacidade de desenvolver em full stack.. Formação superior completa\nou em andamento em Ciências da Computação, Sistemas de Informação ou áreas\nafins.</p>\n<p><strong _mstmutation=\"1\" _msttexthash=\"616499\" _msthash=\"447\" style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Complementares</strong></strong><br></p>\n<p _msttexthash=\"1865474\" _msthash=\"438\">Conhecimento em GIT, JAVA, C#, .NET, Angular,\nReact e NodeJS.</p><font _mstmutation=\"1\" _msttexthash=\"1647516\" _msthash=\"441\"><strong _mstmutation=\"1\"><strong></strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\" _mstmutation=\"1\">Horário:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\" _mstmutation=\"1\"> Segunda a sexta, das 08h às 18h.\nPresencial.</span></font>\n<p></p>\n<p _msttexthash=\"615355\" _msthash=\"319\"><strong _msttexthash=\"260793\" _msthash=\"446\"><strong>O que oferecemos</strong></strong><br></p>\n<p _msttexthash=\"8266557\" _msthash=\"440\">Plano de saúde Unimed, vale-transporte ou fretado\n(dependendo da região), refeitório no local e seguro de vida coletivo.</p>\n<p></p>\n<p><font _mstmutation=\"1\"></font><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955736,"hash":"LR4573W6","position_name":"Designer de produto - UX/UI","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"6825\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"6824\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"6823\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"6822\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"6821\"></font></p><ul><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"6821\">\n <li _msttexthash=\"1662570\" _msthash=\"6951\">Atua diretamente no desenvolvimento de produtos,</li>\n <li _msttexthash=\"7325318\" _msthash=\"6952\">Elabora pesquisas, análises em campo dos produtos a serem criados      ou validados (user experience/user interface);</li>\n <li _msttexthash=\"4060095\" _msthash=\"6953\">Cria conceitos e explora possibilidades de soluções para os      produtos da empresa,</li>\n <li _msttexthash=\"1955083\" _msthash=\"6954\">Acompanha o desenvolvimento de modelos e protótipos,</li>\n <li _msttexthash=\"2727959\" _msthash=\"6955\">Define parâmetros ergonômicos de interface humana dos produtos,</li>\n <li _msttexthash=\"5700708\" _msthash=\"6956\">Interage com demais áreas, acompanhando a evolução do projeto e      avalia dificuldades encontradas,</li>\n <li _msttexthash=\"3662126\" _msthash=\"6957\">Elabora ilustrações conceituais através de desenhos manuais e/ou      digitais,</li>\n <li _msttexthash=\"1211249\" _msthash=\"6958\">Modela superfícies com software 3D (Alias),</li>\n</font></ul><br><p></p>\n<p _msttexthash=\"6685016\" _msthash=\"6820\"><strong><strong>Requisitos Obrigatórios</strong></strong><br></p><ul>\n <li _msttexthash=\"1966705\" _msthash=\"6959\">Graduação completa em Design de produto ou cursos afim,</li>\n <li _msttexthash=\"1999387\" _msthash=\"6960\">Desejável experiência de 2 a 4 anos com design de produto,</li>\n <li _msttexthash=\"823524\" _msthash=\"6961\">Necessário conhecimento em UX/UI;</li>\n <li _msttexthash=\"1101633\" _msthash=\"6962\">Necessário conhecimento em ergonomia;</li>\n <li _msttexthash=\"1770275\" _msthash=\"6963\">Necessário conhecimento em metodologias de Design;</li>\n <li _msttexthash=\"1479205\" _msthash=\"6964\">Necessário experiência com software 3D (Alias),</li>\n <li _msttexthash=\"1493427\" _msthash=\"6965\">Necessário conhecimento em modelagem de dados,</li>\n <li _msttexthash=\"902577\" _msthash=\"6966\">Esboço manual/digital (photoshop)</li>\n</ul>\n<p></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955696,"hash":"LR4573VX","position_name":"Designer Sênior","description":"<p><font _mstmutation=\"1\" _msttexthash=\"46462286\" _msthash=\"3762\">Junte-se a família PTC Group 🤩</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"226126680\" _msthash=\"3763\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙</font><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"265504850\" _msthash=\"3764\">Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀</font><br></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"3765\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"3766\"></font></p>\n<p _msttexthash=\"58494293\" _msthash=\"3880\"><font _mstmutation=\"1\" _msttexthash=\"3623243\" _msthash=\"3766\">Liderar e coordenar as atividades do time de Design, acompanhando todo o processo, desde a criação até a prototipação final, junto a equipe de designers, garantindo os processos de Design, as premissas e linguagem definidas para o produto, realizando entregas dentro dos prazos, custos estimados, alinhado com a estratégia da Empresa.</font></p><br><p></p>\n<p _msttexthash=\"6685016\" _msthash=\"3767\"><strong><strong><font _mstmutation=\"1\" _msttexthash=\"579345\" _msthash=\"3893\">Requisitos Obrigatórios</font></strong></strong></p>\n<p _msttexthash=\"874068\" _msthash=\"3894\"><font _mstmutation=\"1\" _msttexthash=\"918749\" _msthash=\"3895\">. Experiencia em Design automotivo;</font><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong><font _mstmutation=\"1\"></font></strong></p>\n<p _msttexthash=\"6685016\" _msthash=\"3767\"></p><ul>\n <li _msttexthash=\"2699775\" _msthash=\"3881\">Propõe conceitos para novos projetos de ONIBUS externo ou interno.</li>\n <li _msttexthash=\"2845024\" _msthash=\"3882\">Lidera projetos de maiores complexidades, atendendo a cronogramas.</li>\n <li _msttexthash=\"3876899\" _msthash=\"3883\">Contribui com novas metodologias e conhecimentos para aprimoramento      da equipe.</li>\n <li _msttexthash=\"2998385\" _msthash=\"3884\">Viaja junto a equipe multidisciplinar, representando o setor de      DESIGN.</li>\n</ul>\n<p></p>\n<p _msttexthash=\"3680599\" _msthash=\"3768\"><strong><strong>Requisitos Complementares</strong></strong><br></p><ul>\n <li _msttexthash=\"1144650\" _msthash=\"3885\">Graduação completa em Design de produto</li>\n <li _msttexthash=\"987948\" _msthash=\"3886\">Experiência no segmento automotivo</li>\n <li _msttexthash=\"786838\" _msthash=\"3887\">Desejável inglês e/ou espanhol</li>\n <li _msttexthash=\"185575\" _msthash=\"3888\">ALIAS AVANÇADO</li>\n <li _msttexthash=\"280878\" _msthash=\"3889\">PHOTOSHOP AVANÇADO</li>\n <li _msttexthash=\"212628\" _msthash=\"3890\">MANUAL DE ESBOÇO</li>\n <li _msttexthash=\"246584\" _msthash=\"3891\">RENDERIZAR DIGITAL</li>\n <li _msttexthash=\"180440\" _msthash=\"3892\">LIQUIDIFICADOR</li>\n</ul>\n<p></p>\n<p _msttexthash=\"2734823\" _msthash=\"3769\"><strong><strong>O que oferecemos</strong></strong><br>(completar - se não houver, elimitar esse tópico)</p>\n<p></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959584,"hash":"LR45W6VX","position_name":"DevOps","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um DevOps Júnior&nbsp;para um projecto na área financeira, na zona de Lisboa, em regime híbrido.</span><br></p>\n<p>O DevOps&nbsp;será responsável por:</p>\n<p></p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li><strong><strong>﻿﻿</strong></strong>Participar na conceção de uma infraestrutura de pipelines de dados escalável, que se ajuste ao volume de dados.</li><li>Gerir uma base de dados que mantenha uma cronologia clara das principais características dos dados, assim como das métricas e benchmarks dos modelos.</li><li>Assegurar o versionamento dos modelos desenvolvidos offline, incluindo todas as métricas relevantes.</li><li>Aplicar práticas rigorosas de qualidade no desenvolvimento de código, com a inclusão de testes unitários que suportem CI/CD e promovam a automação contínua.</li><li>Apoiar o processo de implementação de modelos, desenvolvendo uma pipeline de deployment e garantindo os testes necessários.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li><strong><strong>﻿﻿﻿</strong></strong>Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +1 anos em Hadoop (Kafka, Hive, etc).</li><li>Experiência com CI/CD.</li><li>Conhecimentos em Python, Docker e Spark (ETL).</li><li>Experiência em SQL e MongoDB (nice-to-have).</li><li>Experiência com orquestação (Kedri, Airflow e Argo) (nice-to-have).</li><li>Experiência com Cloud e integração de APIs (nice-to-have).</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1767530,"hash":"L4YRV57V","position_name":"Diretor de Produção","description":"<p>O nosso cliente fabrica moldes de aço para injeção de plásticos técnicos e de alto desempenho, destacando-se pela precisão e repetibilidade em todos os componentes, baseando-se em mais de 30 anos de conhecimento e oferecendo um serviço técnico personalizado.</p>\n<p>Atualmente encontram-se a recrutar um <strong>Diretor de Produção&nbsp;</strong></p>\n<p><strong>Requisitos do Candidato:</strong></p>\n<ul><li>Licenciatura em Engenharia de Moldes, Mecânica ou Gestão Industrial (preferencial);</li><li>Mínimo de 5 anos de experiência em funções semelhantes (preferencial);</li><li>Excelentes conhecimentos de Injeção plásticas e/ou moldes</li><li>Conhecimentos das normas relacionadas com a área de injeção de plásticos;</li><li>Fluência em inglês;</li><li>Excelente capacidade de liderança e organização;</li><li>Forte orientação para resultados.</li></ul>\n<p><strong>Descrição de Funções:</strong></p>\n<ul><ul><li>Liderar e chefiar a equipa de produção, garantindo um ambiente de trabalho colaborativo e produtivo;</li><li>Definir estratégias e metas para a produção, assegurando a máxima eficiência e qualidade;</li><li>Monitorizar e otimizar os processos de produção, identificando oportunidades de melhoria contínua;</li><li>Coordenar com outros departamentos para garantir uma comunicação eficaz e uma colaboração harmoniosa;</li><li>Garantir o cumprimento das normas de segurança, saúde e qualidade;</li><li>Manter-se atualizado(a) sobre as tendências e avanços na indústria.</li></ul></ul>","country":"Portugal","state":"Leiria District","city":"Marinha Grande","address":"","zipcode":"","location_display":"Marinha Grande, Leiria District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718322,"hash":"L8RVV94R","position_name":"Engenheiro Body Structures","description":"<p>Engenheiro sênior de desenvolvimento Body Structures (BIW), com experiência mínima de 5 anos na função, presencial em Camaçari.</p>\n<p>Obrigatório: Inglês avançado /&nbsp;fluente</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718540,"hash":"QY7YY7R9","position_name":"Engenheiro de Coxim de Motor / Anti Vibração","description":"<p>Engenheiro sênior para desenvolvimento de coxim de motor, com pelo menos 5 anos de experiência na função,&nbsp;presencial em Camaçari.</p>\n<p>Obrigatório: Inglês avançado / fluente</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p>\n<p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1729009,"hash":"L77RV6YX","position_name":"Engenheiro de Custos - Body","description":"<p><ul><li>Fornecer suporte à equipe Global de Engenharia de Custos de Projetos (PCE).</li><li>Engenheiro de Custos do Projeto será responsável por desenvolver custos técnicos variáveis e de ferramentas para um conjunto atribuído de componentes e sistemas usando metodologias de custeio baseadas em atividades enquanto trabalha a partir de BOM (lista de materiais), desenhos e/ou amostras. ·</li><li>Os engenheiros devem fornecer experiência no assunto para apoiar a engenharia e as compras nos níveis de trabalho e a liderança do programa de veículos em todas as fases de desenvolvimento. </li><li>O Engenheiro deve ter a capacidade de analisar cotações de fornecedores e chegar a um acordo sobre os custos apropriados. </li><li>O Engenheiro precisa ser capaz de interagir com a equipe em iniciativas de Design to Cost, benchmarking, custos diretos de materiais e ferramentas.</li><li>Apoiar projetos com suporte de custos desde as fases/marcos iniciais de desenvolvimento até a vida serial do domínio do componente solicitado.</li><li>Desenvolvimento de Custeio em apoio à Estimativa Técnica e/ou Custo com base em características técnicas, especificações e Lista de Materiais</li><li>Propor saving e otimização durante os milestones dos veículos e o desenvolvimento de metas de custos. Insira diretamente ideias de economia de custos de design no Sistema de Portfólio de Oportunidades PCE ·</li><li>Suporte como participante de equipe multifuncional ativo para Engenharia, Equipe de Veículos e Compras. Fornecimento de deltas de custos baseados em dados para fechamento de lacunas de metas e cotações.</li><li> Negociação de ajuda e suporte durante RFQ de componentes, notas de alteração, marcos do veículo</li><li>O perímetro do Engenheiro de Custos inclui componentes atribuídos dentro de uma equipe de subunidade dentro do PCE. As subunidades são definidas por carroceria, chassi, interior, componentes/módulos elétricos, equipes de propulsão ·</li><li>Espera-se que o Engenheiro de Custos forneça resultados de análise de custos em sistemas/arquivos apropriados, conforme definido pelo cliente</li><li>Espera-se resultados da análise de custos documentados e apresentados às equipes do programa de veículos conforme exigido regionalmente</li><li>Realizar entradas dentro dos Sistemas Globais de Documentação PCE e Rastreamento de KPI </li><li>Espera-se idéias de economia técnica e de design para custos colocadas no banco de dados de oportunidades de custo do portfólio</li></ul>\n<h2>Qualificações</h2>\n<ul><li>Bacharel em Administração, Finanças, matemática ou Engenharia ·</li><li>Experiência em funções de design, liberação ou processamento; ou outras credenciais em combinação com experiência relevante no desenvolvimento de custos variáveis e/ou de ferramentas para componentes automotivos ·</li><li>Conhecimento automotivo de métodos de produção e processos de desenvolvimento no setor automotivo</li><li>Orientado a detalhes com capacidade de gerenciar vários programas e detalhes de custos simultaneamente</li><li>habilidades interpessoais e de comunicação com o inglês como língua oficial para comunicação (escrita e oral) ·</li><li>Capacidade de trabalhar em uma equipe global</li><li> </li></ul>\n<h2>Informações Adicionais</h2>\n<p>Desejável: </p>\n<ul><li>Grau Avançado em Negócios. ·</li><li>Proficiência em NX e Teamcenter.</li><li>Experiência em custeio baseado em atividades ou experiência no desenvolvimento de modelos de custo.</li></ul>\n<p></p>\n<p>Modelo de trabalho híbrido em BETIM/MG.</p>\n<p>Por isso a localidade do candidato deve atender Belo Horizonte e região metropolitana.</p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933681,"hash":"L763WYVX","position_name":"Engenheiro de Dados","description":"<p>Nosso cliente é uma multinacional brasileira com atuação em 7 países.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Experiencia em implementação de data pipelines, processando em batch e real time;﻿</li><li>Ferramenta Power BI (DAX e M);</li><li>SQL Server e Azure SQL Database;</li><li>Azure Data Lake e Azure Data Factory;</li><li>Databricks (Delta Lake);</li><li>Noções de PowerBI;</li><li>Python, Pyspark e airfflow.</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Conhecer estatística, pandas, numpy ;<br>Conhecimento em docker e cloud.</p>\n<p><strong>Mandatório</strong><br></p>\n<ul><li>Modelo de Trabalho: Remoto</li><li>Contratação: Prestador de Serviços</li><li>Senioridade: Sênior</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:55 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=10","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=8","results":[{"id":1929086,"hash":"QWYVX486","position_name":"Desenvolvedor Front - React Pl/Sr","description":"<p>Nosso cliente é ﻿um dos principais players do agronegócio brasileiro, oferecendo produtos e serviços de alta qualidade e com uma equipe qualificada para atender as necessidades dos produtores rurais em qualquer uma de suas 30 filiais, com presença em 6 estados.</p>\n<p><strong>Responsabilidades e Tarefas da Função﻿﻿</strong></p>\n<ul>\n<li>Desenvolver interfaces de usuário responsivas e intuitivas para aplicativos web e móveis utilizando React;</li>\n<li>Colaborar com designers e desenvolvedores back-end para traduzir requisitos de negócios e designs em soluções técnicas viáveis;</li>\n<li>Utilizar as melhores práticas de desenvolvimento front-end para garantir desempenho, escalabilidade e segurança;</li>\n<li>Manter-se atualizado com as tendências e tecnologias emergentes no campo do desenvolvimento front-end, incluindo o aprendizado de NestJS;</li>\n<li>Realizar revisões de código e garantir a qualidade do software através de testes rigorosos;</li>\n<li>Identificar e resolver problemas técnicos e de usabilidade durante todo o ciclo de vida do projeto;</li>\n<li>Participar ativamente de reuniões e colaborar com outros membros da equipe para alcançar objetivos comuns.</li>\n</ul>\n<p><strong>Requisitos Obrigatórios﻿﻿</strong></p>\n<ul>\n<li>Experiência comprovada como desenvolvedor front-end, preferencialmente com foco em React e Javascript;</li>\n<li>Sólido conhecimento de conceitos como HTML, CSS, Javascript (ES6+), e frameworks como React e Redux;</li>\n<li>Experiência com ferramentas de controle de versão, como Git;</li>\n<li>Familiaridade com princípios de design responsivo e acessibilidade;</li>\n<li>Capacidade comprovada de traduzir requisitos de design e negócios em código limpo, reutilizável e bem documentado;</li>\n<li>Excelentes habilidades de comunicação e trabalho em equipe;</li>\n<li>Formação acadêmica em Ciência da Computação, Engenharia de Software ou área relacionada (desejável, mas não obrigatória).</li>\n</ul>\n<p><strong>Requisitos Complementares﻿</strong></p>\n<ul>\n<li>Experiência com NextJS (desejável);</li>\n<li>Conhecimento de ferramentas de build e otimização, como Webpack e Babel;</li>\n<li>Experiência com testes unitários e de integração;</li>\n<li>Inglês (desejável não mandatário);</li>\n<li>Perfil hands-on;</li>\n<li>Trabalho em equipe;</li>\n<li>Resolução de problemas;</li>\n<li>Adaptabilidade;</li>\n<li>Pensamento crítico;</li>\n<li>Gerenciamento de tempo;</li>\n<li>Empatia;</li>\n<li>Resiliência;</li>\n<li>Auto aprendizado;</li>\n<li>Criatividade;</li>\n<li>Ética profissional.</li>\n</ul>\n<p></p>\n<p><strong>Informações Adicionais</strong>:</p>\n<ul>\n<li>Contratação: Prestador de Serviços (PJ)</li>\n<li>Modelo de Trabalho: Remoto</li>\n</ul>","country":"Brazil","state":"","city":"Mato Grosso","address":"","zipcode":"","location_display":"Mato Grosso, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1965233,"hash":"L7693W55","position_name":"Desenvolvedor Full Stack","description":"<p>Nosso cliente é ﻿um dos principais players do agronegócio brasileiro, oferecendo produtos e serviços de alta qualidade e com uma equipe qualificada para atender as necessidades dos produtores rurais em qualquer uma de suas 30 filiais, com presença em 6 estados.</p>\n<p><strong>Responsabilidades e Tarefas da Função﻿﻿﻿</strong></p>\n<ul>\n<li>Desenvolver e implementar funcionalidades completas para aplicações web e móveis utilizando React (front-end) e Java (back-end);</li>\n<li>Colaborar com designers, product managers e outros desenvolvedores para traduzir requisitos de negócio em soluções técnicas viáveis;</li>\n<li>Escrever código limpo, reutilizável, bem documentado e testável, seguindo as melhores práticas de desenvolvimento front-end e back-end;</li>\n<li>Manter-se atualizado com as tendências e tecnologias emergentes em ambos os lados da pilha (front-end e back-end), incluindo o aprendizado de NestJS;</li>\n<li>Realizar revisões de código e garantir a qualidade do software através de testes unitários, de integração e automatizados;</li>\n<li>Identificar e resolver problemas técnicos de front-end, back-end e integração entre ambos os lados;</li>\n<li>Participar ativamente de reuniões e colaborar com outros membros da equipe para alcançar objetivos comuns.</li>\n</ul>\n<p><strong>Requisitos Obrigatórios﻿﻿﻿</strong></p>\n<ul>\n<li>Experiência comprovada como desenvolvedor full-stack, com sólidos conhecimentos em front-end (React, Javascript, HTML, CSS) e back-end (Java, Spring Boot, JPA, Hibernate);</li>\n<li>Experiência com APIs RESTful e integração entre front-end e back-end;</li>\n<li>Familiaridade com bancos de dados relacionais (MySQL ou PostgreSQL);</li>\n<li>Experiência com ferramentas de controle de versão (Git);</li>\n<li>Capacidade comprovada de traduzir requisitos de design e negócios em código de alta qualidade;</li>\n<li>Excelentes habilidades de comunicação, trabalho em equipe e resolução de problemas;</li>\n<li>Formação acadêmica em Ciência da Computação, Engenharia de Software ou área relacionada (desejável, mas não obrigatória).</li>\n</ul>\n<p><strong>Requisitos Complementares﻿﻿</strong></p>\n<ul>\n<li>Experiência com NextJS (desejável);</li>\n<li>Conhecimento de ferramentas de build e otimização (Webpack, Babel);</li>\n<li>Experiência com microsserviços e frameworks relacionados (Spring Cloud);</li>\n<li>Experiência com Docker e Kubernetes;</li>\n<li>Inglês (desejável não mandatário);</li>\n<li>Perfil hands on;</li>\n<li>Adaptabilidade;</li>\n<li>Pensamento crítico;</li>\n<li>Gerenciamento de tempo;</li>\n<li>Empatia;</li>\n<li>Resiliência;</li>\n<li>Autoaprendizado;</li>\n<li>Criatividade;</li>\n<li>Ética profissional.</li>\n</ul>","country":"Brazil","state":"","city":"Mato Grosso","address":"","zipcode":"","location_display":"Mato Grosso, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1937033,"hash":"L763VR65","position_name":"Desenvolvedor Mobile React Native","description":"<p>Nosso cliente é uma multinacional brasileira com 45 anos de atuações, sediada em Cuiabá, atualmente é uma das empresas líderes do Agronegócio na América Latina e com atuação em 7 países. Além de trading a companhia tem ramificação nas áreas de sementes, transporte fluvial, beneficiamento de soja, geração de energia e na área financeira.</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li>Desenvolver e manter aplicativos móveis utilizando React Native;</li><li>Colaborar com designers e outros membros da equipe para entender requisitos de negócios e traduzi-los em soluções técnicas;</li><li>Garantir a qualidade do código, incluindo testes unitários e integração contínua;</li><li>Otimizar o desempenho dos aplicativos para dispositivos móveis;</li><li>Investigar e resolver problemas, bugs e problemas de desempenho;</li><li>Ficar atualizado(a) com as melhores práticas de desenvolvimento móvel e tendências da indústria.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Experiência comprovada no desenvolvimento de aplicativos móveis usando React Native;</li><li>Sólida compreensão de JavaScript, incluindo ES6/ES7;</li><li>Familiaridade com princípios de design de interface de usuário e experiência do usuário;</li><li>Conhecimento de arquiteturas de aplicativos móveis, padrões de design e melhores práticas;</li><li>Experiência com ferramentas de controle de versão, como Git;</li><li>Capacidade de trabalhar de forma independente e em equipe, com forte habilidade de comunicação;</li><li>Graduação em Ciência da Computação, Engenharia de Software, ou área relacionada (ou experiência equivalente).</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong></p>\n<ul><li>Experiência prévia com desenvolvimento nativo para iOS e/ou Android;</li><li>Conhecimento de ferramentas de CI/CD;</li><li>Familiaridade com GraphQL e APIs RESTful;</li><li>Experiência com metodologias ágeis, como Scrum ou Kanban.</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1753061,"hash":"QVXW77W8","position_name":"Desenvolvedor .Net","description":"<p>Nosso cliente é uma multinacional brasileira com 45 anos de atuações, sediada em Cuiabá, atualmente é uma das empresas líderes do Agronegócio na América Latina e com atuação em 7 países. Além de trading a companhia tem ramificação nas áreas de sementes, transporte fluvial, beneficiamento de soja, geração de energia e na área financeira.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br>\n</p><ul><li>Experiência solida na prática no desenvolvimento de aplicações usando a plataforma .NET e a linguagem C#.</li><li>Experiência com o ciclo de vida completo de desenvolvimento de software, desde a concepção até a implementação e manutenção.</li><li>Profundo conhecimento em C# e .NET Framework/.NET Core.</li><li>Conhecimento aprofundado dos conceitos e práticas relacionadas a APIs, com experiência em desenvolvimento e integração de serviços RESTful e SOAP.</li><li>Expertise em Razor, uma tecnologia utilizada para criação de páginas web dinâmicas com o ASP.NET Core.</li><li>Proficiência no uso do Bootstrap para desenvolvimento de interfaces responsivas e visualmente atrativas.</li><li>Experiência sólida com Docker, incluindo criação, gerenciamento e orquestração de contêineres para garantir a portabilidade e escalabilidade de aplicações.</li><li>Conhecimento sólido em design de software e princípios de arquitetura.</li><li>Habilidade para projetar e desenvolver arquiteturas de software escaláveis e eficientes.</li><li>Conhecimento em padrões de design, como MVC, MVVM, e outros padrões arquiteturais.</li><li>Experiência em desenvolvimento web utilizando ASP.NET, ASP.NET Core, e tecnologias relacionadas.</li><li>Competência em design e otimização de bancos de dados usando SQL Server, Entity Framework ou outras tecnologias de acesso a dados.</li><li>Conhecimento de JavaScript, HTML, CSS e frameworks front-end como Angular ou React.</li><li>Habilidade para colaborar em equipes ágeis usando metodologias como Scrum ou Kanban.</li><li>Consciência e prática de boas práticas de segurança no desenvolvimento de software.</li><li>Boas habilidades de comunicação para colaborar efetivamente com outros membros da equipe, clientes e stakeholders.</li></ul>\n<p></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Complementares</strong></strong><br></p>\n<p>\n</p><ul><li>Modelo de Trabalho: Remoto</li><li>Contratação: Prestador de Serviços</li><li>Senioridade: Sênior</li></ul>\n<p><br></p>\n<p></p>\n<p><br></p>\n<p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1658215,"hash":"QX73R343","position_name":"Desenvolvedor .Net","description":"<p>Nosso cliente é uma multinacional brasileira com 45 anos de atuações, sediada em Cuiabá, atualmente é uma das empresas líderes do Agronegócio na América Latina e com atuação em 7 países. Além de trading a companhia tem ramificação nas áreas de sementes, transporte fluvial, beneficiamento de soja, geração de energia e na área financeira.<br></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>﻿VAGA:&nbsp;Analista de Desenvolvimento&nbsp;.NET&nbsp;</strong></strong><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<ul><li>Experiência solida na&nbsp;prática no desenvolvimento de aplicações usando a plataforma .NET e a linguagem C#.</li><li>Experiência com o ciclo de vida completo de desenvolvimento de software, desde a concepção até a implementação e manutenção.</li><li>Profundo conhecimento em C# e .NET Framework/.NET Core.</li><li>Conhecimento aprofundado dos conceitos e práticas relacionadas a APIs, com experiência em desenvolvimento e integração de serviços RESTful e SOAP.</li><li>Expertise em Razor, uma tecnologia utilizada para criação de páginas web dinâmicas com o ASP.NET Core.</li><li>Proficiência no uso do Bootstrap para desenvolvimento de interfaces responsivas e visualmente atrativas.</li><li>Experiência sólida com Docker, incluindo criação, gerenciamento e orquestração de contêineres para garantir a portabilidade e escalabilidade de aplicações.</li><li>﻿Conhecimento sólido em design de software e princípios de arquitetura.</li><li>Habilidade para projetar e desenvolver arquiteturas de software escaláveis e eficientes.</li><li>Conhecimento em padrões de design, como MVC, MVVM, e outros padrões arquiteturais.</li><li>Experiência em desenvolvimento web utilizando ASP.NET, ASP.NET Core, e tecnologias relacionadas.</li><li>Competência em design e otimização de bancos de dados usando SQL Server, Entity Framework ou outras tecnologias de acesso a dados.</li><li><span style=\"font-size: 1em;\">Conhecimento de JavaScript, HTML, CSS e frameworks front-end como Angular ou React.</span></li><li>Habilidade para colaborar em equipes ágeis usando metodologias como Scrum ou Kanban.</li><li>Consciência e prática de boas práticas de segurança no desenvolvimento de software.</li><li>Boas habilidades de comunicação para colaborar efetivamente com outros membros da equipe, clientes e stakeholders.</li></ul>\n<p><br><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<ul><li>Modelo de Trabalho: Remoto</li><li>Contratação: Prestador de Serviços</li><li>Senioridade: Sênior</li></ul><p><br></p><p></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1715079,"hash":"L57647RR","position_name":"Desenvolvedor PHP","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\" _msttexthash=\"1135381\" _msthash=\"435\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p _msttexthash=\"1748799\" _msthash=\"316\">\n</p>\n<p _msttexthash=\"22423427\" _msthash=\"436\">Experiência em PHP, SQL, HTML, CSS e\nJavascript.Capacidade de desenvolver em full stack.. Formação superior completa\nou em andamento em Ciências da Computação, Sistemas de Informação ou áreas\nafins.</p>\n<p><strong _mstmutation=\"1\" _msttexthash=\"616499\" _msthash=\"447\" style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Complementares</strong></strong><br></p>\n<p _msttexthash=\"1865474\" _msthash=\"438\">Conhecimento em GIT, JAVA, C#, .NET, Angular,\nReact e NodeJS.</p><font _mstmutation=\"1\" _msttexthash=\"1647516\" _msthash=\"441\"><strong _mstmutation=\"1\"><strong></strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\" _mstmutation=\"1\">Horário:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\" _mstmutation=\"1\"> Segunda a sexta, das 08h às 18h.\nPresencial.</span></font>\n<p></p>\n<p _msttexthash=\"615355\" _msthash=\"319\"><strong _msttexthash=\"260793\" _msthash=\"446\"><strong>O que oferecemos</strong></strong><br></p>\n<p _msttexthash=\"8266557\" _msthash=\"440\">Plano de saúde Unimed, vale-transporte ou fretado\n(dependendo da região), refeitório no local e seguro de vida coletivo.</p>\n<p></p>\n<p><font _mstmutation=\"1\"></font><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SC","city":"Araquari","address":"","zipcode":"","location_display":"Araquari, SC, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955736,"hash":"LR4573W6","position_name":"Designer de produto - UX/UI","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p>\n<ul>\n <li>Atua diretamente no desenvolvimento de produtos,</li>\n <li>Elabora pesquisas, análises em campo dos produtos a serem criados      ou validados (user experience/user interface);</li>\n <li>Cria conceitos e explora possibilidades de soluções para os      produtos da empresa,</li>\n <li>Acompanha o desenvolvimento de modelos e protótipos,</li>\n <li>Define parâmetros ergonômicos de interface humana dos produtos,</li>\n <li>Interage com demais áreas, acompanhando a evolução do projeto e      avalia dificuldades encontradas,</li>\n <li>Elabora ilustrações conceituais através de desenhos manuais e/ou      digitais,</li>\n <li>Modela superfícies com software 3D (Alias),</li>\n</ul>\n<p><br></p><p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul>\n <li>Graduação completa em Design de produto ou cursos afim,</li>\n <li>Desejável experiência de 2 a 4 anos com design de produto,</li>\n <li>Necessário conhecimento em UX/UI;</li>\n <li>Necessário conhecimento em ergonomia;</li>\n <li>Necessário conhecimento em metodologias de Design;</li>\n <li>Necessário experiência com software 3D (Alias),</li>\n <li>Necessário conhecimento em modelagem de dados,</li>\n <li>Esboço manual/digital (photoshop);</li><li>Morar em Caxias do Sul/RS</li>\n</ul>\n<p></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1955696,"hash":"LR4573VX","position_name":"Designer Sênior","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p>\n<p>Liderar e coordenar as atividades do time de Design, acompanhando todo o processo, desde a criação até a prototipação final, junto a equipe de designers, garantindo os processos de Design, as premissas e linguagem definidas para o produto, realizando entregas dentro dos prazos, custos estimados, alinhado com a estratégia da Empresa.</p>\n<p><br></p><p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<p>. Experiencia em Design automotivo;<strong><strong></strong></strong></p>\n<p></p>\n<ul>\n <li>Propõe conceitos para novos projetos de ONIBUS externo ou interno.</li>\n <li>Lidera projetos de maiores complexidades, atendendo a cronogramas.</li>\n <li>Contribui com novas metodologias e conhecimentos para aprimoramento      da equipe.</li>\n <li>Viaja junto a equipe multidisciplinar, representando o setor de      DESIGN.</li>\n</ul>\n<p></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<ul>\n <li>Graduação completa em Design de produto</li>\n <li>Experiência no segmento automotivo</li>\n <li>Desejável inglês e/ou espanhol</li>\n <li>ALIAS AVANÇADO</li>\n <li>PHOTOSHOP AVANÇADO</li>\n <li>MANUAL DE ESBOÇO</li>\n <li>RENDERIZAR DIGITAL</li>\n</ul>\n<p></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"RS","city":"Caxias do Sul","address":"","zipcode":"","location_display":"Caxias do Sul, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959584,"hash":"LR45W6VX","position_name":"DevOps","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um DevOps Júnior&nbsp;para um projecto na área financeira, na zona de Lisboa, em regime híbrido.</span><br></p>\n<p>O DevOps&nbsp;será responsável por:</p>\n<p></p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li><strong><strong>﻿﻿</strong></strong>Participar na conceção de uma infraestrutura de pipelines de dados escalável, que se ajuste ao volume de dados.</li><li>Gerir uma base de dados que mantenha uma cronologia clara das principais características dos dados, assim como das métricas e benchmarks dos modelos.</li><li>Assegurar o versionamento dos modelos desenvolvidos offline, incluindo todas as métricas relevantes.</li><li>Aplicar práticas rigorosas de qualidade no desenvolvimento de código, com a inclusão de testes unitários que suportem CI/CD e promovam a automação contínua.</li><li>Apoiar o processo de implementação de modelos, desenvolvendo uma pipeline de deployment e garantindo os testes necessários.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li><strong><strong>﻿﻿﻿</strong></strong>Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +1 anos em Hadoop (Kafka, Hive, etc).</li><li>Experiência com CI/CD.</li><li>Conhecimentos em Python, Docker e Spark (ETL).</li><li>Experiência em SQL e MongoDB (nice-to-have).</li><li>Experiência com orquestação (Kedri, Airflow e Argo) (nice-to-have).</li><li>Experiência com Cloud e integração de APIs (nice-to-have).</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1767530,"hash":"L4YRV57V","position_name":"Diretor de Produção","description":"<p>O nosso cliente fabrica moldes de aço para injeção de plásticos técnicos e de alto desempenho, destacando-se pela precisão e repetibilidade em todos os componentes, baseando-se em mais de 30 anos de conhecimento e oferecendo um serviço técnico personalizado.</p>\n<p>Atualmente encontram-se a recrutar um <strong>Diretor de Produção&nbsp;</strong></p>\n<p><strong>Requisitos do Candidato:</strong></p>\n<ul><li>Licenciatura em Engenharia de Moldes, Mecânica ou Gestão Industrial (preferencial);</li><li>Mínimo de 5 anos de experiência em funções semelhantes (preferencial);</li><li>Excelentes conhecimentos de Injeção plásticas e/ou moldes</li><li>Conhecimentos das normas relacionadas com a área de injeção de plásticos;</li><li>Fluência em inglês;</li><li>Excelente capacidade de liderança e organização;</li><li>Forte orientação para resultados.</li></ul>\n<p><strong>Descrição de Funções:</strong></p>\n<ul><ul><li>Liderar e chefiar a equipa de produção, garantindo um ambiente de trabalho colaborativo e produtivo;</li><li>Definir estratégias e metas para a produção, assegurando a máxima eficiência e qualidade;</li><li>Monitorizar e otimizar os processos de produção, identificando oportunidades de melhoria contínua;</li><li>Coordenar com outros departamentos para garantir uma comunicação eficaz e uma colaboração harmoniosa;</li><li>Garantir o cumprimento das normas de segurança, saúde e qualidade;</li><li>Manter-se atualizado(a) sobre as tendências e avanços na indústria.</li></ul></ul>","country":"Portugal","state":"Leiria District","city":"Marinha Grande","address":"","zipcode":"","location_display":"Marinha Grande, Leiria District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:41 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=10
@@ -626,11 +626,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:55 GMT
+      - Tue, 30 Jul 2024 16:28:41 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '20583'
+      - '16679'
       Connection:
       - keep-alive
       Server:
@@ -651,8 +651,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=11","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=9","results":[{"id":1769953,"hash":"L39W363W","position_name":"Engenheiro de Dados - Banco de Talentos","description":"<p>Junte-se a família PTC Group!</p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje.</p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos.</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função:</strong></strong></p><ul><ul>\n <li>Responsável pelo gerenciamento e processamento de grandes volumes      de dados;</li>\n <li>Colaboração em projetos financeiros com uma abordagem ágil;</li>\n <li>Levantamento e refinamento de requisitos de dados;</li>\n <li>Desenvolvimento e manutenção de consultas SQL e T-SQL para extração      e manipulação de dados;</li>\n <li>Implementação e gerenciamento de bancos de dados SQL Server e Azure      SQL Database;</li>\n <li>Utilização de conhecimentos gerais da Cloud Azure para integrar      soluções de dados;</li>\n <li>Implementação e manutenção de pipelines de dados usando Azure Data      Lake e Azure Data Factory;</li>\n <li>Utilização de Databricks, especialmente Delta Lake, para      processamento de dados em larga escala;</li>\n <li>Desenvolvimento e manutenção de relatórios e dashboards utilizando      Power BI, com proficiência em DAX e M;</li>\n <li>Utilização de Python e Pyspark para automação e manipulação      avançada de dados;<br>\n     Configuração e gestão de fluxos de trabalho de dados utilizando Apache      Airflow para agendar, monitorar e gerenciar processos de ETL de forma      eficiente.</li></ul></ul>\n<p></p>\n<p><strong><strong>Requisitos:</strong></strong></p><ul><ul>\n <li>Experiência comprovada na utilização da ferramenta Power BI, com      proficiência em DAX e M;</li>\n <li>Habilidade de realizar levantamento e refinamento de requisitos de      dados;</li>\n <li>Domínio de consultas SQL e T-SQL para manipulação de dados;</li>\n <li>Experiência comprovada no gerenciamento de bancos de dados SQL      Server e Azure SQL Database;</li>\n <li>Conhecimento básico da Cloud Azure e suas principais      funcionalidades;</li>\n <li>Experiência na implementação e manutenção de soluções de dados      utilizando Azure Data Lake e Azure Data Factory;</li>\n <li>Experiência prática com Databricks, especialmente em projetos      envolvendo Delta Lake;</li>\n <li>Conhecimentos sólidos em PowerBI para desenvolvimento de relatórios      e dashboards;</li>\n <li>Experiência em programação com Python e utilização de Pyspark para      manipulação de dados;</li>\n <li>Experiência em configuração e gestão de fluxos de trabalho de dados      utilizando Apache Airflow.</li></ul></ul>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718418,"hash":"L4755447","position_name":"Engenheiro de Peças Plásticas","description":"<p>Engenheiro senior para desenvolvimento de peças plásticas, com pelo menos 5 anos de experiencia em projetos de carroceria,&nbsp;</p><p>presencial em Camaçari.</p>\n<p>Obrigatório: Inglês avançado / fluente.</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p><p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718440,"hash":"QY7YY845","position_name":"Engenheiro de teto solar","description":"<p>Engenheiro para desenvolvimento de teto solar, com pelo menos 5 anos de experiência em mecanismo de teto solar,&nbsp;<span style=\"font-family: inherit; font-size: 0.875rem;\">presencial em Camaçari.</span><p>Obrigatório: Inglês avançado / fluente</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716635,"hash":"L9VW579Y","position_name":"Engenheiro Eletrônico - PL","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Engenheiro Eletrônico Pleno desempenha um papel essencial na equipe de engenharia, liderando e contribuindo para o design, implementação e manutenção de sistemas eletrônicos. Este profissional possui experiência substancial em eletrônica e assume responsabilidades-chave para garantir a integridade e eficácia dos componentes eletrônicos dos produtos da empresa.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Design Eletrônico: Liderar o design de circuitos eletrônicos para produtos específicos, considerando requisitos de desempenho, eficiência energética e segurança.</p>\n<p>Prototipagem e Testes: Coordenar a prototipagem de circuitos e sistemas eletrônicos, realizando testes rigorosos para validar o funcionamento adequado.</p>\n<p>Seleção de Componentes: Selecionar e especificar componentes eletrônicos, garantindo conformidade com requisitos técnicos e orçamentários.</p>\n<p>Análise de Desempenho: Realizar análises de desempenho de circuitos eletrônicos, identificando áreas de melhoria e otimização.</p>\n<p>Colaboração com Desenvolvimento de Software: Trabalhar em estreita colaboração com desenvolvedores de software para garantir a integração eficaz entre componentes eletrônicos e software.</p>\n<p>Gestão de Projetos: Gerenciar projetos eletrônicos desde a concepção até a implementação, assegurando o cumprimento de prazos e padrões de qualidade.</p>\n<p>Projetar Implantações: produzir projetos e procedimentos para implantação e operacionalização dos produtos de hardware</p>\n<p>Documentação Técnica: Elaborar documentação técnica detalhada, incluindo esquemas elétricos, manuais de produto e relatórios de teste, e ministrar treinamento de equipes de implantação e manutenção.</p>\n<p>Resolução de Problemas: Identificar e resolver problemas técnicos relacionados a circuitos eletrônicos, colaborando com equipes multidisciplinares.</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Formação em Engenharia Eletrônica, Engenharia Elétrica ou áreas afins.</p>\n<p>Experiência de mais de 5 anos em design e implementação de circuitos eletrônicos.</p>\n<p>Conhecimento em ferramentas de design assistido por computador (CAD) para eletrônica e mecânica.</p>\n<p>Familiaridade com normas e regulamentações relevantes da indústria.</p>\n<p>Habilidade para liderar projetos e colaborar efetivamente com equipes multifuncionais.</p>\n<p>Excelentes habilidades de comunicação e documentação técnica.</p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Informações Adicionais</strong><span style=\"font-family: inherit; font-size: 0.875rem;\">:</span><br></p>\n<ul><li>Presencial em São José dos Campos/SP</li><li>Contratação PJ</li></ul><p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1931028,"hash":"QY4X68WV","position_name":"Especialista de Projetos","description":"<p>Junte-se a família PTC Group</p><p>Estamos sempre a procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje.</p><p><strong>Somos uma multinacional de Engenharia e TI</strong>, constituída por uma equipa versátil e movida pela busca incessante da excelência e inovação em todas as nossas iniciativas.</p><p><strong>FORMAÇÃO:</strong>  Nível Superior completo em Engenharia, Administração ou Afins</p>\n<p><strong>IDIOMA:</strong> Inglês intermediário</p>\n<p><strong>REQUISITOS:</strong></p>\n<ul><li>Experiência no ramo automotivo, com experiencia em PLM BOM atuando no perímetro Body e/ou Chassis e/ou Interior e/ou Mechatronics.</li><li>Pacote Office Avançado</li><li>Conhecimento em PLM, SAP, CATIA</li></ul>\n<p><strong>FUNÇÃO A SER OCUPADA:</strong> BOM Pilot - PMO BCI</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1756377,"hash":"L395Y85V","position_name":"Facility Manager","description":"<p>Nos encontramos en la búsqueda de&nbsp;un perfil Facility Manager en el seno del equipo de Operaciones de una importante empresa gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p>\n<p><strong>Tareas:</strong></p>\n<ul><li>Elaboración y supervisión del plan preventivo de mantenimiento de los edificios.</li><li>Mantenimiento integral de los edificios.</li><li>Propuesta y seguimiento de acciones correctivas en los edificios.</li><li>Gestión de toda la documentación técnica asociada a los edificios.</li><li>Recepción de activos de obra nueva.</li><li>Gestión de todos los servicios asociados a los edificios: seguridad, suministros, limpieza, conserjería, jardinería, etc.</li><li>Gestión de garantías de los fabricantes de equipos principales.</li><li>Coordinación de las operaciones de reacondicionamiento de las viviendas.</li><li>Resolución de incidencias privativas en las viviendas.</li><li>Negociación, contratación y seguimiento de contratos marco de servicios asociados a las intervenciones en las viviendas (electricidad, fontanería, pintura, carpintería, etc.).</li><li>Selección y gestión de subcontratistas necesarios para el buen funcionamiento del departamento.</li></ul>\n<p><strong>Requisitos del Candidato:</strong><br></p>\n<ul><li>Graduado en Arquitectura Técnica / Ingeniería de Edificación.</li><li>Se valorarán positivamente estudios y cursos adicionales relacionados con el campo.</li><li>Experiencia mínima de 3 años en puestos de responsabilidad asociados a la construcción y mantenimiento de edificios, preferiblemente en el ámbito residencial. Se dará especial consideración a aquellos candidatos con experiencia en funciones realizadas directamente en obra.</li><li>Dominio de herramientas de ofimática y Autocad.</li><li>Nivel medio-alto de inglés.</li></ul>\n<p>﻿Si cumples con estos requisitos y estás interesado en unirte a nuestro equipo como Responsable de Gestión de Activos, ¡esperamos recibir tu solicitud!</p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1931248,"hash":"LR43Y49R","position_name":"Flashing Engineer","description":"<p><strong>Job Description: Flashing Engineer</strong></p>\n<p><strong>﻿Location:&nbsp;﻿San Luis Potosi, Mexico</strong></p>\n<p><br></p>\n<p><strong></strong><strong>Company Overview:</strong>\nPTC Group is currently seeking a Flashing Engineer for a leading German company in the automotive sector. This position offers an exciting opportunity to work at the forefront of automotive technology, focusing on plastic injection and electronic devices.</p>\n<p><br></p>\n<p><strong>Responsibilities and Tasks:</strong></p>\n<ul><li>Develop and maintain expertise in automotive flashing protocols such as CAN, CAN-FD, ISO-K, and FlexRay.</li><li>Utilize programming languages, particularly C#, to enhance flashing processes.</li><li>Troubleshoot and optimize PLC process flows, logs, and machine test processes.</li><li>Debug log files related to flashing operations.</li><li>Oversee assembly line processes and troubleshoot issues related to functional test stations, including electronics and assembly tests like leakage testing, force tests, and actuators.</li><li>Familiarity with cryptographic methods (JTAG, HSM, UCB) on Microcontrollers, with a preference for experience with Infineon and Freescale.</li><li>Proficiency in memory maps on automotive-focused Microcontrollers.</li><li>Conduct flashing operations over SoCs (System on Chips) and MCUs (Microcontrollers).</li><li>Knowledge of Manufacturing Execution Systems (MES) to integrate flashing and testing processes.</li></ul>\n<p><strong>Mandatory Skills:</strong></p>\n<ul><li>3 to 5 years of professional experience.</li><li>Experience with multi-party communication systems and workflows (e.g., ECU-IPC-PLC-MES) using various communication interfaces.</li><li>Proficiency in communication interfaces such as TCP/IP, Serial, and MQTT, including understanding of their structures.</li><li>Ability to manage data conversion and raw process data for flashing and testing operations within MES environments.</li></ul>\n<p><strong>Desired Skills:</strong></p>\n<ul><li>Background in electronics and automation.</li><li>Previous experience with plastic injection processes in the automotive industry.</li><li>Familiarity with assembly line automation and troubleshooting.</li></ul>\n<p><strong>Qualifications:</strong></p>\n<ul><li>Bachelors degree in Electrical Engineering, Computer Engineering, or related field.</li><li>Proven experience in automotive flashing and testing operations.</li><li>Strong analytical skills and problem-solving ability.</li><li>Ability to work effectively in a collaborative team environment.</li><li>Excellent communication skills in English.</li></ul>","country":"Mexico","state":"San Luis Potosi","city":"","address":"","zipcode":"","location_display":"San Luis Potosi, Mexico","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1710349,"hash":"QV7V8R86","position_name":"Front Desk Receptionist (International School)","description":"<p>Nos encontramos en la búsqueda de un&nbsp;perfil con experiencia en atención al cliente, secretariado técnico en el sector educativo y/o con experiencia en Front Desk de hoteles internacionales. La posición es de atención al público en un centro educativo, tratando a alumnos, profesores y padres.</p>\n<p><strong><br></strong></p><p><strong>Requisitos</strong></p>\n\n\n\n\n\n\n\n\n\n<ul><li> Preferiblemente experiencia en secretariado técnico en el sector educativo.</li><li> Se valorará experiencia como Front Desk de grandes hoteles o similar.</li><li> Experiencia en atención al cliente en entorno multinacional, recepción y secretariado.</li><li> Dominio de idiomas, inglés nivel alto.</li><li> Manejo preciso y ágil de sistemas de información. Conocimientos informáticos.</li><li> Conocimientos de gestión de listas, turnos, asistencia, incidencias, ocupación.</li><li> Conocimientos de facturación, cobros y gestión de incidencias.</li><li> Capacidad de gestión de eventos, presupuestos, gestión de mercancías y pedidos.</li><li> Archivo y documentación.</li><li> Gestión de intranet, comunicaciones y flujos de mensajería</li></ul><p></p><p><strong>Ofrecemos</strong></p>\n<p>Formar parte de un grupo educativo referente en el sector con una posición estable y a largo plazo.</p>\n\n<ul><li> Contrato indefinido</li><li> Salario según experiencia y titulación.</li><li> Beneficios sociales</li></ul>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828800,"hash":"LR4RVR66","position_name":"Gear Cutting Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title:&nbsp;Gear Cutting&nbsp;Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in process of gear cutting (hobbing, shaping, milling, broaching, grinding, etc.)</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1727000,"hash":"LRW8796X","position_name":"GERENTE DE TRANSPORTE","description":"<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p> Gerir os transportadores (inbound e outbound, transferências entre unidades) medir o nível de serviço dos atuais, aderência da grade de carregamento nas unidades. <br> Desenvolver novos transportadores. <br> Desenvolver e gerir um programa de renovação de frotas. <br> Gerir contratos de prestação de serviços monitorando todas os aspectos necessários, monitorar apólices de seguros. <br> Monitorar e gerir os treinamentos dos motoristas parceiros. <br> Gerir conta Frete, realizar orçamentos, avaliar possíveis projetos a fim de reduzir a CONTA FRETE e MELHORAR NIVEL DE SERVIÇO. <br> Entregar nível de serviço para o time comercial. <br> Visita em clientes quando necessário. <br> Gerir indicadores do setor. <br> Apresentar alternativas com viabilidade econômica.<br> Gestão de equipe corporativa e equipes nas unidades. <br> Superior completo: Engenharia, Logística e Administração<br> Experiência em Distribuidores e Atacadistas de qualquer segmento ou ter atuado em transportadoras ou operadoras logística.</p>\n<p><strong><strong>Requisitos Suplementares</strong> </strong><br> Necessário morar no ES e disponibilidade para viagem em 70% do tempo. <br>Contabilidade e tributário e legislação de transportes, conhecimento de custos de transportes (combustível, veículos, formação de custo, manutenção).&nbsp;</p>\n<p>Profissional   Analítico com muito relacionamento, gostar de operação e principalmente   tem experiência de gestão com MOTORISTA e TRANSPORTADORA.</p>","country":"Brazil","state":"ES","city":"Serra","address":"","zipcode":"","location_display":"Serra, ES, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:55 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=11","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=9","results":[{"id":1718322,"hash":"L8RVV94R","position_name":"Engenheiro Body Structures","description":"<p>Engenheiro sênior de desenvolvimento Body Structures (BIW), com experiência mínima de 5 anos na função, presencial em Camaçari.</p>\n<p>Obrigatório: Inglês avançado /&nbsp;fluente</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718540,"hash":"QY7YY7R9","position_name":"Engenheiro de Coxim de Motor / Anti Vibração","description":"<p>Engenheiro sênior para desenvolvimento de coxim de motor, com pelo menos 5 anos de experiência na função,&nbsp;presencial em Camaçari.</p>\n<p>Obrigatório: Inglês avançado / fluente</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p>\n<p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1729009,"hash":"L77RV6YX","position_name":"Engenheiro de Custos - Body","description":"<p><ul><li>Fornecer suporte à equipe Global de Engenharia de Custos de Projetos (PCE).</li><li>Engenheiro de Custos do Projeto será responsável por desenvolver custos técnicos variáveis e de ferramentas para um conjunto atribuído de componentes e sistemas usando metodologias de custeio baseadas em atividades enquanto trabalha a partir de BOM (lista de materiais), desenhos e/ou amostras. ·</li><li>Os engenheiros devem fornecer experiência no assunto para apoiar a engenharia e as compras nos níveis de trabalho e a liderança do programa de veículos em todas as fases de desenvolvimento. </li><li>O Engenheiro deve ter a capacidade de analisar cotações de fornecedores e chegar a um acordo sobre os custos apropriados. </li><li>O Engenheiro precisa ser capaz de interagir com a equipe em iniciativas de Design to Cost, benchmarking, custos diretos de materiais e ferramentas.</li><li>Apoiar projetos com suporte de custos desde as fases/marcos iniciais de desenvolvimento até a vida serial do domínio do componente solicitado.</li><li>Desenvolvimento de Custeio em apoio à Estimativa Técnica e/ou Custo com base em características técnicas, especificações e Lista de Materiais</li><li>Propor saving e otimização durante os milestones dos veículos e o desenvolvimento de metas de custos. Insira diretamente ideias de economia de custos de design no Sistema de Portfólio de Oportunidades PCE ·</li><li>Suporte como participante de equipe multifuncional ativo para Engenharia, Equipe de Veículos e Compras. Fornecimento de deltas de custos baseados em dados para fechamento de lacunas de metas e cotações.</li><li> Negociação de ajuda e suporte durante RFQ de componentes, notas de alteração, marcos do veículo</li><li>O perímetro do Engenheiro de Custos inclui componentes atribuídos dentro de uma equipe de subunidade dentro do PCE. As subunidades são definidas por carroceria, chassi, interior, componentes/módulos elétricos, equipes de propulsão ·</li><li>Espera-se que o Engenheiro de Custos forneça resultados de análise de custos em sistemas/arquivos apropriados, conforme definido pelo cliente</li><li>Espera-se resultados da análise de custos documentados e apresentados às equipes do programa de veículos conforme exigido regionalmente</li><li>Realizar entradas dentro dos Sistemas Globais de Documentação PCE e Rastreamento de KPI </li><li>Espera-se idéias de economia técnica e de design para custos colocadas no banco de dados de oportunidades de custo do portfólio</li></ul>\n<h2>Qualificações</h2>\n<ul><li>Bacharel em Administração, Finanças, matemática ou Engenharia ·</li><li>Experiência em funções de design, liberação ou processamento; ou outras credenciais em combinação com experiência relevante no desenvolvimento de custos variáveis e/ou de ferramentas para componentes automotivos ·</li><li>Conhecimento automotivo de métodos de produção e processos de desenvolvimento no setor automotivo</li><li>Orientado a detalhes com capacidade de gerenciar vários programas e detalhes de custos simultaneamente</li><li>habilidades interpessoais e de comunicação com o inglês como língua oficial para comunicação (escrita e oral) ·</li><li>Capacidade de trabalhar em uma equipe global</li><li> </li></ul>\n<h2>Informações Adicionais</h2>\n<p>Desejável: </p>\n<ul><li>Grau Avançado em Negócios. ·</li><li>Proficiência em NX e Teamcenter.</li><li>Experiência em custeio baseado em atividades ou experiência no desenvolvimento de modelos de custo.</li></ul>\n<p></p>\n<p>Modelo de trabalho híbrido em BETIM/MG.</p>\n<p>Por isso a localidade do candidato deve atender Belo Horizonte e região metropolitana.</p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933681,"hash":"L763WYVX","position_name":"Engenheiro de Dados","description":"<p>Nosso cliente é uma multinacional brasileira com atuação em 7 países.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Experiencia em implementação de data pipelines, processando em batch e real time;﻿</li><li>Ferramenta Power BI (DAX e M);</li><li>SQL Server e Azure SQL Database;</li><li>Azure Data Lake e Azure Data Factory;</li><li>Databricks (Delta Lake);</li><li>Noções de PowerBI;</li><li>Python, Pyspark e airfflow.</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Conhecer estatística, pandas, numpy ;<br>Conhecimento em docker e cloud.</p>\n<p><strong>Mandatório</strong><br></p>\n<ul><li>Modelo de Trabalho: Remoto</li><li>Contratação: Prestador de Serviços</li><li>Senioridade: Sênior</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1769953,"hash":"L39W363W","position_name":"Engenheiro de Dados - Banco de Talentos","description":"<p>Junte-se a família PTC Group!</p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje.</p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos.</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função:</strong></strong></p><ul><ul>\n <li>Responsável pelo gerenciamento e processamento de grandes volumes      de dados;</li>\n <li>Colaboração em projetos financeiros com uma abordagem ágil;</li>\n <li>Levantamento e refinamento de requisitos de dados;</li>\n <li>Desenvolvimento e manutenção de consultas SQL e T-SQL para extração      e manipulação de dados;</li>\n <li>Implementação e gerenciamento de bancos de dados SQL Server e Azure      SQL Database;</li>\n <li>Utilização de conhecimentos gerais da Cloud Azure para integrar      soluções de dados;</li>\n <li>Implementação e manutenção de pipelines de dados usando Azure Data      Lake e Azure Data Factory;</li>\n <li>Utilização de Databricks, especialmente Delta Lake, para      processamento de dados em larga escala;</li>\n <li>Desenvolvimento e manutenção de relatórios e dashboards utilizando      Power BI, com proficiência em DAX e M;</li>\n <li>Utilização de Python e Pyspark para automação e manipulação      avançada de dados;<br>\n     Configuração e gestão de fluxos de trabalho de dados utilizando Apache      Airflow para agendar, monitorar e gerenciar processos de ETL de forma      eficiente.</li></ul></ul>\n<p></p>\n<p><strong><strong>Requisitos:</strong></strong></p><ul><ul>\n <li>Experiência comprovada na utilização da ferramenta Power BI, com      proficiência em DAX e M;</li>\n <li>Habilidade de realizar levantamento e refinamento de requisitos de      dados;</li>\n <li>Domínio de consultas SQL e T-SQL para manipulação de dados;</li>\n <li>Experiência comprovada no gerenciamento de bancos de dados SQL      Server e Azure SQL Database;</li>\n <li>Conhecimento básico da Cloud Azure e suas principais      funcionalidades;</li>\n <li>Experiência na implementação e manutenção de soluções de dados      utilizando Azure Data Lake e Azure Data Factory;</li>\n <li>Experiência prática com Databricks, especialmente em projetos      envolvendo Delta Lake;</li>\n <li>Conhecimentos sólidos em PowerBI para desenvolvimento de relatórios      e dashboards;</li>\n <li>Experiência em programação com Python e utilização de Pyspark para      manipulação de dados;</li>\n <li>Experiência em configuração e gestão de fluxos de trabalho de dados      utilizando Apache Airflow.</li></ul></ul>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718418,"hash":"L4755447","position_name":"Engenheiro de Peças Plásticas","description":"<p>Engenheiro senior para desenvolvimento de peças plásticas, com pelo menos 5 anos de experiencia em projetos de carroceria,&nbsp;</p><p>presencial em Camaçari.</p>\n<p>Obrigatório: Inglês avançado / fluente.</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p><p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1718440,"hash":"QY7YY845","position_name":"Engenheiro de teto solar","description":"<p>Engenheiro para desenvolvimento de teto solar, com pelo menos 5 anos de experiência em mecanismo de teto solar,&nbsp;<span style=\"font-family: inherit; font-size: 0.875rem;\">presencial em Camaçari.</span><p>Obrigatório: Inglês avançado / fluente</p>\n<p>Preferência por candidatos sem passagem pela Ford.</p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716635,"hash":"L9VW579Y","position_name":"Engenheiro Eletrônico - PL","description":"<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p>\n</p>\n<p>O Engenheiro Eletrônico Pleno desempenha um papel essencial na equipe de engenharia, liderando e contribuindo para o design, implementação e manutenção de sistemas eletrônicos. Este profissional possui experiência substancial em eletrônica e assume responsabilidades-chave para garantir a integridade e eficácia dos componentes eletrônicos dos produtos da empresa.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p>Design Eletrônico: Liderar o design de circuitos eletrônicos para produtos específicos, considerando requisitos de desempenho, eficiência energética e segurança.</p>\n<p>Prototipagem e Testes: Coordenar a prototipagem de circuitos e sistemas eletrônicos, realizando testes rigorosos para validar o funcionamento adequado.</p>\n<p>Seleção de Componentes: Selecionar e especificar componentes eletrônicos, garantindo conformidade com requisitos técnicos e orçamentários.</p>\n<p>Análise de Desempenho: Realizar análises de desempenho de circuitos eletrônicos, identificando áreas de melhoria e otimização.</p>\n<p>Colaboração com Desenvolvimento de Software: Trabalhar em estreita colaboração com desenvolvedores de software para garantir a integração eficaz entre componentes eletrônicos e software.</p>\n<p>Gestão de Projetos: Gerenciar projetos eletrônicos desde a concepção até a implementação, assegurando o cumprimento de prazos e padrões de qualidade.</p>\n<p>Projetar Implantações: produzir projetos e procedimentos para implantação e operacionalização dos produtos de hardware</p>\n<p>Documentação Técnica: Elaborar documentação técnica detalhada, incluindo esquemas elétricos, manuais de produto e relatórios de teste, e ministrar treinamento de equipes de implantação e manutenção.</p>\n<p>Resolução de Problemas: Identificar e resolver problemas técnicos relacionados a circuitos eletrônicos, colaborando com equipes multidisciplinares.</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Formação em Engenharia Eletrônica, Engenharia Elétrica ou áreas afins.</p>\n<p>Experiência de mais de 5 anos em design e implementação de circuitos eletrônicos.</p>\n<p>Conhecimento em ferramentas de design assistido por computador (CAD) para eletrônica e mecânica.</p>\n<p>Familiaridade com normas e regulamentações relevantes da indústria.</p>\n<p>Habilidade para liderar projetos e colaborar efetivamente com equipes multifuncionais.</p>\n<p>Excelentes habilidades de comunicação e documentação técnica.</p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Informações Adicionais</strong><span style=\"font-family: inherit; font-size: 0.875rem;\">:</span><br></p>\n<ul><li>Presencial em São José dos Campos/SP</li><li>Contratação PJ</li></ul><p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São José dos Campos","address":"","zipcode":"","location_display":"São José dos Campos, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1931028,"hash":"QY4X68WV","position_name":"Especialista de Projetos","description":"<p>Junte-se a família PTC Group</p><p>Estamos sempre a procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje.</p><p><strong>Somos uma multinacional de Engenharia e TI</strong>, constituída por uma equipa versátil e movida pela busca incessante da excelência e inovação em todas as nossas iniciativas.</p><p><strong>FORMAÇÃO:</strong>  Nível Superior completo em Engenharia, Administração ou Afins</p>\n<p><strong>IDIOMA:</strong> Inglês intermediário</p>\n<p><strong>REQUISITOS:</strong></p>\n<ul><li>Experiência no ramo automotivo, com experiencia em PLM BOM atuando no perímetro Body e/ou Chassis e/ou Interior e/ou Mechatronics.</li><li>Pacote Office Avançado</li><li>Conhecimento em PLM, SAP, CATIA</li></ul>\n<p><strong>FUNÇÃO A SER OCUPADA:</strong> BOM Pilot - PMO BCI</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1962906,"hash":"L4Y5Y387","position_name":"Especialista de Projetos - Amortecedores","description":"<p>Junte-se a família PTC Group</p>\n<p>Estamos sempre a procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje.</p>\n<p><strong>Somos uma multinacional de Engenharia e TI</strong>, constituída por uma equipa versátil e movida pela busca incessante da excelência e inovação em todas as nossas iniciativas.</p>\n<p><strong>FORMAÇÃO:</strong> Nível Superior completo em Engenharia, Administração ou Afins</p>\n<p><strong>IDIOMA:</strong> Inglês intermediário</p>\n<p><strong>REQUISITOS:</strong></p>\n<ul><li>Experiência no ramo automotivo;</li><li>Experiência com projetos de suspensão;</li><li>Experiência comprovado com amortecedores;</li><li>Pacote Office;</li><li>Disponibilidade para atuar em Betim.</li></ul>\n<p><strong>FUNÇÃO A SER OCUPADA:</strong> Especialista em amortecedores</p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:42 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=11
@@ -672,11 +672,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:56 GMT
+      - Tue, 30 Jul 2024 16:28:42 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '29266'
+      - '30144'
       Connection:
       - keep-alive
       Server:
@@ -697,8 +697,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=12","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=10","results":[{"id":1956374,"hash":"QWYW4376","position_name":"High Voltage Battery and Sub-system Cost Engineer","description":"<p><strong>Position: High Voltage Battery and Sub-system Cost Engineer</strong></p>\n<p><strong>Location:&nbsp;﻿Saltillo, Coahuila, Mexico</strong></p>\n<p><br></p>\n<p><strong></strong><strong>Job Summary:</strong></p>\n<p>The High Voltage Battery and Sub-system Cost Engineer, reporting to the Cost Engineering Propulsion High Voltage Battery Manager, is responsible for the design, technical, industrial, and economic aspects of electronics and electro-mechanical components used in battery management systems, battery disconnection units, and battery thermal management systems. This role focuses on cost evaluation and design-to-cost strategies for electro-mechanical components in electrified vehicles, including BEVs, PHEVs, HEVs, and MHEVs.</p>\n<p><strong><br></strong></p>\n<p><strong>Key Responsibilities:</strong></p>\n<ul><li>﻿Technical and Economic Expertise: Maintain up-to-date knowledge of power electronic design, electronic components, electrical pumps, and battery disconnection units (BDUs) for BEVs, through continuous engagement with stakeholders including engineering teams, Tier 1 &amp; 2 suppliers, and other partners.</li><li>Technology Insight: Stay informed on the latest advancements and technologies in the field.</li><li>Data Management: Manage a structured database of procured parts, detailing their technical and economic attributes.</li><li>Cost Evaluation: Perform \"Should Cost\" analyses for Tier 1 parts, including calculating the GWP (Global Warming Potential) impact using Price Breakdown (PBD) analysis.</li><li>Cross-functional Collaboration: Work closely with engineering, project management, and purchasing teams to ensure competitive process costs while meeting all technical, timeline, and quality requirements.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Qualifications and Skills:</strong></p>\n<ul><li>Since 5 years of professional experience.﻿</li><li>Direct experience in electronics and e-pump design.</li><li>Technical Knowledge: In-depth understanding of power electronics architecture, semiconductor and magnetics technology, materials, and PCB production processes. Proficient in die casting, stamping, and flexible printed circuit (FPC) processes.</li><li>Education: Master's degree in Electrical or Electro-mechanical Engineering.</li><li>Interpersonal Skills: Strong teamwork, negotiation skills, and communication abilities, with experience working in global teams.</li><li>Language and Tools: Proficiency in English and MS Office tools.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Collaboration:</strong></p>\n<ul><li>With Tier 1 Suppliers: For technical negotiations and design-to-cost strategies.</li><li>With Tier 2 Suppliers: For gaining technical and economic insights on electronic and magnetic parts.</li><li>With Engineering: To support cost evaluations and design-to-cost initiatives.</li><li>With Purchasing and Value Optimization Teams: To assist in technical negotiations with suppliers during sourcing and change management processes for both ongoing development and serial production.</li><li>With GWP Team: For CO2 breakdown analysis and calculations.</li></ul>","country":"Mexico","state":"Coahuila","city":"Saltillo","address":"","zipcode":"","location_display":"Saltillo, Coahuila, Mexico","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1936520,"hash":"L64YR5W5","position_name":"Industrial Construction Supervisor (OPEX) - Bayonne, France","description":"<p><strong>Job Position: </strong>﻿<strong>Industrial Construction Supervisor (OPEX)</strong></p>\n<p><strong>﻿Location: Bayonne, France<br></strong></p>\n<p>﻿PTC Group is recruiting an Industrial Construction Supervisor for a client company in the sustainable fish farming sector, focused on opportunities in logistics, distribution and aquaculture.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission</strong></p>\n<p>Ensure that new facilities comply with the company strategy related to the expansion and innovation, acting as supervisor of the entire construction project and aligning all parts with its goal.</p>\n<p><strong>Main objectives</strong></p>\n<ul><li>Ensure that the tendering process responds to the needs and specs of the project.</li><li>Focus the construction with the goals (Schedule, Cost, Scope, and Quality) and specifications defined for each project within the area of responsibility</li><li>Work in a collaborative way with all areas involved in the construction and start-up of the project.</li><li>Respect the work instructions that apply to the position according to the Quality and Environment System.</li></ul>\n<p><strong>Tasks</strong></p>\n<ul><li>Manage the tendering process, evaluate different alternatives, and proposing the best one based on project goals (schedule, cost, scope and quality).</li><li>Coordinate and manage the construction process, ensuring the construction complies with the goals (Schedule, Cost, Scope, and Quality) and specifications defined for each project within the area of responsibility (Fish, Food or Maintenance) in coordination with Functional Maintenance ﻿(in the first step), Functional Production/Construction (in the last two steps), and the Project Leader (from the beginning).</li><li>Identify weaknesses or errors in design and/or construction and propose solutions to resolve them and/or improve operations, in coordination with Functional Construction, Design Area and the Project Leader.</li><li>Coordinate and manage the cold start up (without fish) in coordination with Functional Construction and the Project Leader; Collaborate during the startup (with fish) with the needs identified during the process.</li><li>Responsible for reporting along the construction, startup, and closure.</li><li>Development of technical documentation for grants. It includes the application, the follow-up, the supervision during and after the concession and its closing.</li></ul>\n<p>﻿﻿</p>\n<p><strong>Organization</strong></p>\n<ul><li>Division: Operations</li><li>Area or Department: Engineering &amp; Maintenance</li><li>Need to travel: Yes, 10% both nationally and internationally﻿</li><li>Reports to: Execution &amp; Startup Manager, and Project Leader</li><li>Has reports: Yes</li><li>Work regime: 100% in person, 40 hours a week (8am-1pm; 2pm-5pm).﻿</li><li>80% of the work involves dealing with main contractors in the field; then it also includes the purchase, management and implementation of industrial equipment.﻿</li></ul>\n<p><strong>Job profile/ Requirements</strong></p>\n<ul><li>University degree in Civil works, engineering building or industrial engineering.</li><li>Studies in project management are a plus.</li><li>At least 3-5 years of experience in industrial construction supervision.</li><li>Experience in digital tools.</li><li>Mandatory knowledge of local civil and industrial regulations.﻿</li><li>Multidisciplinary knowledge and experience: industrial, sandy soil movement, building (prefabricated structures, precast concrete), common electrical installations (such as fire protection), hydraulics (water treatment, purifiers, filtration, pumps, piping, sanitation).</li><li>Mandatory proficiency in French.</li><li>Mandatory proficiency in&nbsp;Spanish or English.</li><li>Be able to supervise a large project and have an overall vision of it.</li><li>Be able to work with main contractors and multidisciplinary teams.</li><li>Analytic and critical mindset.</li></ul>","country":"France","state":"","city":"Baiona","address":"","zipcode":"","location_display":"Baiona, France","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1936516,"hash":"QY4X59V5","position_name":"Industrial Construction Supervisor (OPEX) - Ribeira, Spain","description":"<p><strong>Job Position: </strong>﻿<strong>Industrial Construction Supervisor (OPEX)</strong></p>\n<p><strong>﻿Location: Ribeira, A Coruña, Spain<br></strong></p>\n<p>﻿PTC Group is recruiting an Industrial Construction Supervisor for a client company in the sustainable fish farming sector, focused on opportunities in logistics, distribution and aquaculture.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission</strong></p>\n<p>Ensure that new facilities comply with the company strategy related to the expansion and innovation, acting as supervisor of the entire construction project and aligning all parts with its goal.</p>\n<p><strong>Main objectives</strong></p>\n<ul>\n <li>Ensure that the tendering process responds to the      needs and specs of the project.</li>\n <li>Focus the construction with the goals (Schedule,      Cost, Scope, and Quality) and specifications defined for each project      within the area of responsibility</li>\n <li>Work in a collaborative way with all areas involved      in the construction and start-up of the project.</li>\n <li>Respect the work instructions that apply to the      position according to the Quality and Environment System.</li>\n</ul>\n<p><strong>Tasks</strong></p>\n<ul>\n <li>Manage the tendering process, evaluate different      alternatives, and proposing the best one based on project goals (schedule,      cost, scope and quality).</li>\n <li>Coordinate and manage the construction process,      ensuring the construction complies with the goals (Schedule, Cost, Scope,      and Quality) and specifications defined for each project within the area      of responsibility (Fish, Food or Maintenance) in coordination      with Functional Maintenance ﻿(in the first step), Functional      Production/Construction (in the last two steps), and the Project      Leader (from the beginning).</li>\n <li>Identify weaknesses or errors in design and/or      construction and propose solutions to resolve them and/or improve      operations, in coordination with Functional Construction, Design Area and      the Project Leader.</li>\n <li>Coordinate and manage the cold start up (without      fish) in coordination with Functional Construction and the Project      Leader; Collaborate during the startup (with fish) with the needs      identified during the process.</li>\n <li>Responsible      for reporting along the construction, startup, and closure.</li>\n <li>Development      of technical documentation for grants. It includes the application, the follow-up, the      supervision during and after the concession and its closing.</li>\n</ul>\n<p>﻿﻿</p>\n<p><strong>Organization</strong></p>\n<ul>\n <li>Division: Operations</li>\n <li>Area or      Department: Engineering &amp; Maintenance</li>\n <li>Need to travel: Yes, 10% both nationally and      internationally﻿</li>\n <li>Reports to: Execution &amp; Startup Manager,      and Project Leader</li>\n <li>Has      reports: Yes</li>\n <li>Work regime: 100% in person, 40 hours a week      (8am-1pm; 2pm-5pm).﻿</li>\n <li>80% of the work involves dealing with main      contractors in the field; then it also includes the purchase, management      and implementation of industrial equipment.﻿</li>\n</ul>\n<p><strong>Job profile/ Requirements</strong></p>\n<ul>\n <li>University degree in Civil works, engineering      building or industrial engineering.</li>\n <li>Studies in project management are a plus.</li>\n <li>At      least 3-5 years of experience in industrial construction supervision.</li>\n <li>Experience      in digital tools.</li>\n <li>Mandatory      knowledge of local civil and industrial regulations.﻿</li>\n <li>Multidisciplinary      knowledge and experience: industrial, sandy soil movement, building      (prefabricated structures, precast concrete), common electrical      installations (such as fire protection), hydraulics (water treatment,      purifiers, filtration, pumps, piping, sanitation).</li>\n <li>Mandatory proficiency in English; Spanish is a plus.</li>\n <li>Be able      to supervise a large project and have an overall vision of it.</li>\n <li>Be able      to work with main contractors and multidisciplinary teams.</li>\n <li>Analytic      and critical mindset.</li>\n</ul>","country":"Spain","state":"A Coruña","city":"Coruña","address":"","zipcode":"","location_display":"Coruña, A Coruña, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828804,"hash":"QY4535V5","position_name":"Industrial Design Engineer (CSI) - Process","description":"<p><strong>Job Title: Industrial Design Engineer (CSI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p><strong><br></strong></p>\n<p><strong>Company Description</strong>: Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission:</strong></p>\n<p>Responsible for:</p>\n<ul><li>Ensuring the application of construction and safety standards</li><li>Fostering good technical relationships with suppliers within their area of responsibility</li><li>Ensuring proper physical receipt and integration of equipment</li><li>Guaranteeing that purchased equipment meets defined performance standards</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Higher education in Mechanical Engineering or similar fields</li><li>Knowledge of factory design layouts</li><li>Knowledge of 2D design (AutoCAD or equivalent)</li><li>Knowledge of 3D design (SolidWorks, Catia, Inventor, etc.) is a plus</li><li>Experience in internal factory logistics flows</li><li>Knowledge of automation (conveyors, robots, gantries, etc.)</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1805043,"hash":"L53RV3VR","position_name":"Ingeniero de Proyectos","description":"<p>Nuestro cliente es una importante empresa minorista fabricante de colchones&nbsp;incluidos todos sus componentes, muebles, accesorios y equipos relacionados.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Estamos en busca de un/a ingeniero/a o arquitecto/a para unirse al equipo y liderar la expansión comercial de la empresa. El candidato seleccionado será responsable de la supervisión y ejecución de las obras de los&nbsp;nuevos locales comerciales.</span></p>\n<h3>Responsabilidades:</h3>\n<ul><li><strong>Planificación y coordinación</strong> de proyectos de construcción en nuevos locales.</li><li><strong>Supervisión de la ejecución</strong> de obras para asegurar que se cumplan los plazos y presupuestos establecidos.</li><li><strong>Colaboración con otros departamentos</strong> para garantizar que los nuevos locales cumplan con los estándares de la empresa.</li><li><strong>Gestión de licencias y permisos</strong> necesarios para la realización de las obras.</li><li><strong>Realización de informes periódicos</strong> sobre el estado de los proyectos.</li></ul>\n<h3>Requisitos:</h3>\n<ul><li><strong>Título universitario</strong> en Ingeniería o Arquitectura.</li><li><strong>Experiencia mínima de 3 años</strong> en proyectos de construcción o expansión comercial.</li><li><strong>Conocimientos en normativas y regulaciones</strong> de construcción.</li><li><strong>Habilidad para trabajar en equipo</strong> y coordinar múltiples proyectos simultáneamente.</li><li><strong>Excelentes habilidades de comunicación y organización</strong>.</li><li><strong>Nivel de inglés medio-alto</strong>.</li></ul>\n<h3>¿Qué ofrecemos?:</h3>\n<ul><li>Un <strong>ambiente de trabajo dinámico y colaborativo</strong>.</li><li><strong>Oportunidades de crecimiento y desarrollo profesional</strong>.</li><li><strong>Salario competitivo</strong> acorde a la experiencia y formación del candidato.</li><li><strong>Beneficios adicionales</strong>.</li></ul>\n<p>Si cumples con los requisitos y estás interesado en formar parte del equipo no dudes en apuntarte a la oferta&nbsp;¡Esperamos conocerte!</p>","country":"Spain","state":"CT","city":"Barcelona","address":"","zipcode":"","location_display":"Barcelona, CT, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959734,"hash":"L86VRX73","position_name":"Jira Administrator","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um Jira Administrator para reforçar a equipa, em regime remoto.</span></p>\n<p>Este Administrator&nbsp;será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Aplicar atualizações de software e realizar backups regulares para assegurar a segurança e a estabilidade do sistema Jira.</li><li>Fornecer suporte técnico para resolver problemas dos utilizadores e oferecer formação sobre o uso eficiente do Jira.</li><li>Criar e configurar novos projetos e fluxos de trabalho, ajustando as configurações conforme as necessidades da organização.</li><li>Elaborar um plano de migração, realizar backups, transferir dados e testar a nova instância para garantir uma transição suave.</li><li>Implementar melhorias com base no feedback dos utilizadores e fornecer suporte contínuo e eficácia da nova instância do Jira.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +2 anos como Jira Administrator.</li><li>Conhecimentos de ferramentas Office (Excel, Word, Acess)</li><li>Conhecimentos de SQL, Java (Groovy) e JavaScript (JSON) (nice-to-have).</li><li>Conhecimentos em outras ferramentas Atlassian (Confluence) (nice-to-have).</li><li>Conhecimentos de ERPs, CRMs e UI Paths (nice-to-have).</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1946519,"hash":"L53X6885","position_name":"Junior Sales Representative - Engineering Services","description":"<p><span dir=\"ltr\"></span></p>\n<p><strong>Job Title:</strong> Junior Sales Representative - Engineering Services</p>\n<p><strong>Location:</strong> Galicia Region</p>\n<p><strong>Job Summary: </strong>We are seeking a proactive and motivated Junior Sales Representative to support the expansion of our engineering services in the Galicia Region. This role is ideal for an entry-level professional looking to develop their career in sales, focused on engineering services.</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Support the sales team in identifying and prospecting new clients in the Galicia Region.</li><li>Maintain and develop relationships with existing clients.</li><li>Assist in preparing commercial proposals and negotiating contracts.</li><li>Collaborate with the technical team to ensure customer satisfaction and delivery of engineering solutions.</li><li>Update and manage the CRM with relevant information about clients and sales opportunities.</li></ul>\n<p><strong>Requirements:</strong></p>\n<ul><li>Degree in Engineering, Business Administration, Marketing, or a related field.</li><li>Previous experience in sales or customer service is a plus.</li><li>Excellent communication skills and ability to build strong relationships.</li><li>Proactivity, determination, and a desire to learn and grow in sales.</li><li>Willingness to travel within the Galicia Region.</li><li>Languages: Spanish and English.</li></ul>\n<p></p>","country":"Spain","state":"","city":"Galicia","address":"","zipcode":"","location_display":"Galicia, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1946512,"hash":"LR43599R","position_name":"KAM Engineering Services","description":"<p><span dir=\"ltr\" data-redactor-span=\"true\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\">Job Title:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\"> KAM Engineering Services</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\">Location:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\"> Spain</span></p>\n<p><strong>Job Summary: </strong>We are looking for an experienced Key Account Manager (KAM) to manage and develop key accounts across various engineering sectors. This professional will be responsible for strengthening client relationships and driving revenue growth.</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Manage a portfolio of key accounts, ensuring high levels of customer satisfaction and retention.</li><li>Develop strategies to identify and capitalize on new business opportunities in engineering services.</li><li>Collaborate with project teams to ensure successful delivery of engineering solutions.</li><li>Negotiate contracts and commercial terms with clients.</li><li>Stay updated on market trends and competition, adjusting strategies as necessary.</li><li>Produce regular performance reports and sales forecasts for management.</li></ul>\n<p><strong>Requirements:</strong></p>\n<ul><li>Bachelor's degree in Engineering, Business Administration, or a related field.</li><li>Minimum of 3-5 years of experience as a KAM in engineering services.</li><li>Excellent communication, negotiation, and relationship-building skills.</li><li>Ability to work independently and in a team environment.</li><li>Willingness to travel frequently.</li><li>Languages: Spanish and English.</li></ul>\n<p></p>","country":"Spain","state":"Municipality of Vigo","city":"Vigo","address":"","zipcode":"","location_display":"Vigo, Municipality of Vigo, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1946499,"hash":"QX3WX84Y","position_name":"KAM Engineering Services - Railway Sector - Spain","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Job Title:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\"> Key Account Manager (KAM) - Engineering Services, Railway Sector</span></p>\n<p><strong>Location:</strong> Spain</p>\n<p><strong>Job Summary:</strong>\nWe are seeking a highly qualified Key Account Manager (KAM) to lead and manage our key accounts in the railway sector. The ideal candidate will have extensive experience in railway engineering services, with exceptional relationship management skills and the ability to identify and exploit new business opportunities.</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Manage and develop key accounts in the railway sector, ensuring customer satisfaction and business growth.</li><li>Identify new business opportunities and develop strategies to expand the company's presence in the railway market.</li><li>Negotiate contracts and commercial agreements, securing advantageous terms for both parties.</li><li>Monitor and analyze market trends in the railway sector, adapting strategies accordingly.</li><li>Prepare and present performance reports and sales forecasts to senior management.</li></ul>\n<p><strong>Requirements:</strong></p>\n<ul><li>Bachelor's degree in Engineering, Business Administration, or a related field.</li><li>Minimum of 5 years of experience in a similar role within the railway sector.</li><li>Excellent communication and negotiation skills.</li><li>Ability to work independently and as part of a team.</li><li>Willingness to travel as required.</li><li>Languages: Spanish and English.</li></ul>","country":"Spain","state":"","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1957332,"hash":"L649R54W","position_name":"Key Account Manager Executive Search","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Junte-se a família PTC Group </font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. </font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Somos uma multinacional, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. </font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Desenvolver carteira de clientes com foco em Executive Search;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Preparar propostas comerciais alinhadas com as necessidades de cada cliente;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Poder de negociação de valor e não preço;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsável pela satisfação destes clientes;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Manter CRM HUBSPOT atualizado para facilitar as tomadas de decisão.</font></font></li></ul>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência de 5 anos ou mais no setor;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Disponibilidade para viagem;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento de Excel;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Organização;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Boa capacidade de comunicação verbal e escrita;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Perfil mais Hunter do que Farmer.</font></font></li></ul>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Domínio de Power BI;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">10 anos de experiência na função.</font></font></li></ul>\n<p></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Salário fixo;</font></font></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\"></font></font><span style=\"font-family: inherit; font-size: 0.875rem;\">Renda Variável sobre as vendas realizadas;</span></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Trabalho híbrido: segundas feiras no escritório e restante da semana trabalho remoto.</font></font></p>\n<p></p>","country":"Brazil","state":"","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:56 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=12","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=10","results":[{"id":1756377,"hash":"L395Y85V","position_name":"Facility Manager","description":"<p>Nos encontramos en la búsqueda de&nbsp;un perfil Facility Manager en el seno del equipo de Operaciones de una importante empresa gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p>\n<p><strong>Tareas:</strong></p>\n<ul><li>Elaboración y supervisión del plan preventivo de mantenimiento de los edificios.</li><li>Mantenimiento integral de los edificios.</li><li>Propuesta y seguimiento de acciones correctivas en los edificios.</li><li>Gestión de toda la documentación técnica asociada a los edificios.</li><li>Recepción de activos de obra nueva.</li><li>Gestión de todos los servicios asociados a los edificios: seguridad, suministros, limpieza, conserjería, jardinería, etc.</li><li>Gestión de garantías de los fabricantes de equipos principales.</li><li>Coordinación de las operaciones de reacondicionamiento de las viviendas.</li><li>Resolución de incidencias privativas en las viviendas.</li><li>Negociación, contratación y seguimiento de contratos marco de servicios asociados a las intervenciones en las viviendas (electricidad, fontanería, pintura, carpintería, etc.).</li><li>Selección y gestión de subcontratistas necesarios para el buen funcionamiento del departamento.</li></ul>\n<p><strong>Requisitos del Candidato:</strong><br></p>\n<ul><li>Graduado en Arquitectura Técnica / Ingeniería de Edificación.</li><li>Se valorarán positivamente estudios y cursos adicionales relacionados con el campo.</li><li>Experiencia mínima de 3 años en puestos de responsabilidad asociados a la construcción y mantenimiento de edificios, preferiblemente en el ámbito residencial. Se dará especial consideración a aquellos candidatos con experiencia en funciones realizadas directamente en obra.</li><li>Dominio de herramientas de ofimática y Autocad.</li><li>Nivel medio-alto de inglés.</li></ul>\n<p>﻿Si cumples con estos requisitos y estás interesado en unirte a nuestro equipo como Responsable de Gestión de Activos, ¡esperamos recibir tu solicitud!</p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1931248,"hash":"LR43Y49R","position_name":"Flashing Engineer","description":"<p><strong>Job Description: Flashing Engineer</strong></p>\n<p><strong>﻿Location:&nbsp;﻿San Luis Potosi, Mexico</strong></p>\n<p><br></p>\n<p><strong></strong><strong>Company Overview:</strong>\nPTC Group is currently seeking a Flashing Engineer for a leading German company in the automotive sector. This position offers an exciting opportunity to work at the forefront of automotive technology, focusing on plastic injection and electronic devices.</p>\n<p><br></p>\n<p><strong>Responsibilities and Tasks:</strong></p>\n<ul><li>Develop and maintain expertise in automotive flashing protocols such as CAN, CAN-FD, ISO-K, and FlexRay.</li><li>Utilize programming languages, particularly C#, to enhance flashing processes.</li><li>Troubleshoot and optimize PLC process flows, logs, and machine test processes.</li><li>Debug log files related to flashing operations.</li><li>Oversee assembly line processes and troubleshoot issues related to functional test stations, including electronics and assembly tests like leakage testing, force tests, and actuators.</li><li>Familiarity with cryptographic methods (JTAG, HSM, UCB) on Microcontrollers, with a preference for experience with Infineon and Freescale.</li><li>Proficiency in memory maps on automotive-focused Microcontrollers.</li><li>Conduct flashing operations over SoCs (System on Chips) and MCUs (Microcontrollers).</li><li>Knowledge of Manufacturing Execution Systems (MES) to integrate flashing and testing processes.</li></ul>\n<p><strong>Mandatory Skills:</strong></p>\n<ul><li>3 to 5 years of professional experience.</li><li>Experience with multi-party communication systems and workflows (e.g., ECU-IPC-PLC-MES) using various communication interfaces.</li><li>Proficiency in communication interfaces such as TCP/IP, Serial, and MQTT, including understanding of their structures.</li><li>Ability to manage data conversion and raw process data for flashing and testing operations within MES environments.</li></ul>\n<p><strong>Desired Skills:</strong></p>\n<ul><li>Background in electronics and automation.</li><li>Previous experience with plastic injection processes in the automotive industry.</li><li>Familiarity with assembly line automation and troubleshooting.</li></ul>\n<p><strong>Qualifications:</strong></p>\n<ul><li>Bachelors degree in Electrical Engineering, Computer Engineering, or related field.</li><li>Proven experience in automotive flashing and testing operations.</li><li>Strong analytical skills and problem-solving ability.</li><li>Ability to work effectively in a collaborative team environment.</li><li>Excellent communication skills in English.</li></ul>","country":"Mexico","state":"San Luis Potosi","city":"","address":"","zipcode":"","location_display":"San Luis Potosi, Mexico","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1710349,"hash":"QV7V8R86","position_name":"Front Desk Receptionist (International School)","description":"<p>Nos encontramos en la búsqueda de un&nbsp;perfil con experiencia en atención al cliente, secretariado técnico en el sector educativo y/o con experiencia en Front Desk de hoteles internacionales. La posición es de atención al público en un centro educativo, tratando a alumnos, profesores y padres.</p>\n<p><strong><br></strong></p><p><strong>Requisitos</strong></p>\n\n\n\n\n\n\n\n\n\n<ul><li> Preferiblemente experiencia en secretariado técnico en el sector educativo.</li><li> Se valorará experiencia como Front Desk de grandes hoteles o similar.</li><li> Experiencia en atención al cliente en entorno multinacional, recepción y secretariado.</li><li> Dominio de idiomas, inglés nivel alto.</li><li> Manejo preciso y ágil de sistemas de información. Conocimientos informáticos.</li><li> Conocimientos de gestión de listas, turnos, asistencia, incidencias, ocupación.</li><li> Conocimientos de facturación, cobros y gestión de incidencias.</li><li> Capacidad de gestión de eventos, presupuestos, gestión de mercancías y pedidos.</li><li> Archivo y documentación.</li><li> Gestión de intranet, comunicaciones y flujos de mensajería</li></ul><p></p><p><strong>Ofrecemos</strong></p>\n<p>Formar parte de un grupo educativo referente en el sector con una posición estable y a largo plazo.</p>\n\n<ul><li> Contrato indefinido</li><li> Salario según experiencia y titulación.</li><li> Beneficios sociales</li></ul>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828800,"hash":"LR4RVR66","position_name":"Gear Cutting Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title:&nbsp;Gear Cutting&nbsp;Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in process of gear cutting (hobbing, shaping, milling, broaching, grinding, etc.)</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1727000,"hash":"LRW8796X","position_name":"GERENTE DE TRANSPORTE","description":"<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p> Gerir os transportadores (inbound e outbound, transferências entre unidades) medir o nível de serviço dos atuais, aderência da grade de carregamento nas unidades. <br> Desenvolver novos transportadores. <br> Desenvolver e gerir um programa de renovação de frotas. <br> Gerir contratos de prestação de serviços monitorando todas os aspectos necessários, monitorar apólices de seguros. <br> Monitorar e gerir os treinamentos dos motoristas parceiros. <br> Gerir conta Frete, realizar orçamentos, avaliar possíveis projetos a fim de reduzir a CONTA FRETE e MELHORAR NIVEL DE SERVIÇO. <br> Entregar nível de serviço para o time comercial. <br> Visita em clientes quando necessário. <br> Gerir indicadores do setor. <br> Apresentar alternativas com viabilidade econômica.<br> Gestão de equipe corporativa e equipes nas unidades. <br> Superior completo: Engenharia, Logística e Administração<br> Experiência em Distribuidores e Atacadistas de qualquer segmento ou ter atuado em transportadoras ou operadoras logística.</p>\n<p><strong><strong>Requisitos Suplementares</strong> </strong><br> Necessário morar no ES e disponibilidade para viagem em 70% do tempo. <br>Contabilidade e tributário e legislação de transportes, conhecimento de custos de transportes (combustível, veículos, formação de custo, manutenção).&nbsp;</p>\n<p>Profissional   Analítico com muito relacionamento, gostar de operação e principalmente   tem experiência de gestão com MOTORISTA e TRANSPORTADORA.</p>","country":"Brazil","state":"ES","city":"Serra","address":"","zipcode":"","location_display":"Serra, ES, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1956374,"hash":"QWYW4376","position_name":"High Voltage Battery and Sub-system Cost Engineer","description":"<p><strong>Position: High Voltage Battery and Sub-system Cost Engineer</strong></p>\n<p><strong>Location:&nbsp;﻿Saltillo, Coahuila, Mexico</strong></p>\n<p><br></p>\n<p><strong></strong><strong>Job Summary:</strong></p>\n<p>The High Voltage Battery and Sub-system Cost Engineer, reporting to the Cost Engineering Propulsion High Voltage Battery Manager, is responsible for the design, technical, industrial, and economic aspects of electronics and electro-mechanical components used in battery management systems, battery disconnection units, and battery thermal management systems. This role focuses on cost evaluation and design-to-cost strategies for electro-mechanical components in electrified vehicles, including BEVs, PHEVs, HEVs, and MHEVs.</p>\n<p><strong><br></strong></p>\n<p><strong>Key Responsibilities:</strong></p>\n<ul><li>﻿Technical and Economic Expertise: Maintain up-to-date knowledge of power electronic design, electronic components, electrical pumps, and battery disconnection units (BDUs) for BEVs, through continuous engagement with stakeholders including engineering teams, Tier 1 &amp; 2 suppliers, and other partners.</li><li>Technology Insight: Stay informed on the latest advancements and technologies in the field.</li><li>Data Management: Manage a structured database of procured parts, detailing their technical and economic attributes.</li><li>Cost Evaluation: Perform \"Should Cost\" analyses for Tier 1 parts, including calculating the GWP (Global Warming Potential) impact using Price Breakdown (PBD) analysis.</li><li>Cross-functional Collaboration: Work closely with engineering, project management, and purchasing teams to ensure competitive process costs while meeting all technical, timeline, and quality requirements.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Qualifications and Skills:</strong></p>\n<ul><li>Since 5 years of professional experience.﻿</li><li>Direct experience in electronics and e-pump design.</li><li>Technical Knowledge: In-depth understanding of power electronics architecture, semiconductor and magnetics technology, materials, and PCB production processes. Proficient in die casting, stamping, and flexible printed circuit (FPC) processes.</li><li>Education: Master's degree in Electrical or Electro-mechanical Engineering.</li><li>Interpersonal Skills: Strong teamwork, negotiation skills, and communication abilities, with experience working in global teams.</li><li>Language and Tools: Proficiency in English and MS Office tools.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Collaboration:</strong></p>\n<ul><li>With Tier 1 Suppliers: For technical negotiations and design-to-cost strategies.</li><li>With Tier 2 Suppliers: For gaining technical and economic insights on electronic and magnetic parts.</li><li>With Engineering: To support cost evaluations and design-to-cost initiatives.</li><li>With Purchasing and Value Optimization Teams: To assist in technical negotiations with suppliers during sourcing and change management processes for both ongoing development and serial production.</li><li>With GWP Team: For CO2 breakdown analysis and calculations.</li></ul>","country":"Mexico","state":"Coahuila","city":"Saltillo","address":"","zipcode":"","location_display":"Saltillo, Coahuila, Mexico","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1936520,"hash":"L64YR5W5","position_name":"Industrial Construction Supervisor (OPEX) - Bayonne, France","description":"<p><strong>Job Position: </strong>﻿<strong>Industrial Construction Supervisor (OPEX)</strong></p>\n<p><strong>﻿Location: Bayonne, France<br></strong></p>\n<p>﻿PTC Group is recruiting an Industrial Construction Supervisor for a client company in the sustainable fish farming sector, focused on opportunities in logistics, distribution and aquaculture.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission</strong></p>\n<p>Ensure that new facilities comply with the company strategy related to the expansion and innovation, acting as supervisor of the entire construction project and aligning all parts with its goal.</p>\n<p><strong>Main objectives</strong></p>\n<ul><li>Ensure that the tendering process responds to the needs and specs of the project.</li><li>Focus the construction with the goals (Schedule, Cost, Scope, and Quality) and specifications defined for each project within the area of responsibility</li><li>Work in a collaborative way with all areas involved in the construction and start-up of the project.</li><li>Respect the work instructions that apply to the position according to the Quality and Environment System.</li></ul>\n<p><strong>Tasks</strong></p>\n<ul><li>Manage the tendering process, evaluate different alternatives, and proposing the best one based on project goals (schedule, cost, scope and quality).</li><li>Coordinate and manage the construction process, ensuring the construction complies with the goals (Schedule, Cost, Scope, and Quality) and specifications defined for each project within the area of responsibility (Fish, Food or Maintenance) in coordination with Functional Maintenance ﻿(in the first step), Functional Production/Construction (in the last two steps), and the Project Leader (from the beginning).</li><li>Identify weaknesses or errors in design and/or construction and propose solutions to resolve them and/or improve operations, in coordination with Functional Construction, Design Area and the Project Leader.</li><li>Coordinate and manage the cold start up (without fish) in coordination with Functional Construction and the Project Leader; Collaborate during the startup (with fish) with the needs identified during the process.</li><li>Responsible for reporting along the construction, startup, and closure.</li><li>Development of technical documentation for grants. It includes the application, the follow-up, the supervision during and after the concession and its closing.</li></ul>\n<p>﻿﻿</p>\n<p><strong>Organization</strong></p>\n<ul><li>Division: Operations</li><li>Area or Department: Engineering &amp; Maintenance</li><li>Need to travel: Yes, 10% both nationally and internationally﻿</li><li>Reports to: Execution &amp; Startup Manager, and Project Leader</li><li>Has reports: Yes</li><li>Work regime: 100% in person, 39 hours a week.﻿</li><li>80% of the work involves dealing with main contractors in the field; then it also includes the purchase, management and implementation of industrial equipment.﻿</li></ul>\n<p><strong>Job profile/ Requirements</strong></p>\n<ul><li>University degree in Civil works, engineering building or industrial engineering.</li><li>Studies in project management are a plus.</li><li>At least 3-5 years of experience in industrial construction supervision.</li><li>Experience in digital tools.</li><li>Mandatory knowledge of local civil and industrial regulations.﻿</li><li>Multidisciplinary knowledge and experience: industrial, sandy soil movement, building (prefabricated structures, precast concrete), common electrical installations (such as fire protection), hydraulics (water treatment, purifiers, filtration, pumps, piping, sanitation).</li><li>Mandatory proficiency in French.</li><li>Mandatory proficiency in&nbsp;Spanish or English.</li><li>Be able to supervise a large project and have an overall vision of it.</li><li>Be able to work with main contractors and multidisciplinary teams.</li><li>Analytic and critical mindset.</li></ul>","country":"France","state":"","city":"Baiona","address":"","zipcode":"","location_display":"Baiona, France","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1936516,"hash":"QY4X59V5","position_name":"Industrial Construction Supervisor (OPEX) - Ribeira, Spain","description":"<p><strong>Job Position: </strong>﻿<strong>Industrial Construction Supervisor (OPEX)</strong></p>\n<p><strong>﻿Location: Ribeira, A Coruña, Spain<br></strong></p>\n<p>﻿PTC Group is recruiting an Industrial Construction Supervisor for a client company in the sustainable fish farming sector, focused on opportunities in logistics, distribution and aquaculture.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission</strong></p>\n<p>Ensure that new facilities comply with the company strategy related to the expansion and innovation, acting as supervisor of the entire construction project and aligning all parts with its goal.</p>\n<p><strong>Main objectives</strong></p>\n<ul>\n <li>Ensure that the tendering process responds to the      needs and specs of the project.</li>\n <li>Focus the construction with the goals (Schedule,      Cost, Scope, and Quality) and specifications defined for each project      within the area of responsibility</li>\n <li>Work in a collaborative way with all areas involved      in the construction and start-up of the project.</li>\n <li>Respect the work instructions that apply to the      position according to the Quality and Environment System.</li>\n</ul>\n<p><strong>Tasks</strong></p>\n<ul>\n <li>Manage the tendering process, evaluate different      alternatives, and proposing the best one based on project goals (schedule,      cost, scope and quality).</li>\n <li>Coordinate and manage the construction process,      ensuring the construction complies with the goals (Schedule, Cost, Scope,      and Quality) and specifications defined for each project within the area      of responsibility (Fish, Food or Maintenance) in coordination      with Functional Maintenance ﻿(in the first step), Functional      Production/Construction (in the last two steps), and the Project      Leader (from the beginning).</li>\n <li>Identify weaknesses or errors in design and/or      construction and propose solutions to resolve them and/or improve      operations, in coordination with Functional Construction, Design Area and      the Project Leader.</li>\n <li>Coordinate and manage the cold start up (without      fish) in coordination with Functional Construction and the Project      Leader; Collaborate during the startup (with fish) with the needs      identified during the process.</li>\n <li>Responsible      for reporting along the construction, startup, and closure.</li>\n <li>Development      of technical documentation for grants. It includes the application, the follow-up, the      supervision during and after the concession and its closing.</li>\n</ul>\n<p>﻿﻿</p>\n<p><strong>Organization</strong></p>\n<ul>\n <li>Division: Operations</li>\n <li>Area or      Department: Engineering &amp; Maintenance</li>\n <li>Need to travel: Yes, 10% both nationally and      internationally﻿</li>\n <li>Reports to: Execution &amp; Startup Manager,      and Project Leader</li>\n <li>Has      reports: Yes</li>\n <li>Work regime: 100% in person, 40 hours a week.﻿</li>\n <li>80% of the work involves dealing with main      contractors in the field; then it also includes the purchase, management      and implementation of industrial equipment.﻿</li>\n</ul>\n<p><strong>Job profile/ Requirements</strong></p>\n<ul>\n <li>University degree in Civil works, engineering      building or industrial engineering.</li>\n <li>Studies in project management are a plus.</li>\n <li>At      least 3-5 years of experience in industrial construction supervision.</li>\n <li>Experience      in digital tools.</li>\n <li>Mandatory      knowledge of local civil and industrial regulations.﻿</li>\n <li>Multidisciplinary      knowledge and experience: industrial, sandy soil movement, building      (prefabricated structures, precast concrete), common electrical      installations (such as fire protection), hydraulics (water treatment,      purifiers, filtration, pumps, piping, sanitation).</li>\n <li>Mandatory proficiency in English; Spanish is a plus.</li>\n <li>Be able      to supervise a large project and have an overall vision of it.</li>\n <li>Be able      to work with main contractors and multidisciplinary teams.</li>\n <li>Analytic      and critical mindset.</li>\n</ul>","country":"Spain","state":"A Coruña","city":"Coruña","address":"","zipcode":"","location_display":"Coruña, A Coruña, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828804,"hash":"QY4535V5","position_name":"Industrial Design Engineer (CSI) - Process","description":"<p><strong>Job Title: Industrial Design Engineer (CSI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p><strong><br></strong></p>\n<p><strong>Company Description</strong>: Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p><strong><br></strong></p>\n<p><strong>Mission:</strong></p>\n<p>Responsible for:</p>\n<ul><li>Ensuring the application of construction and safety standards</li><li>Fostering good technical relationships with suppliers within their area of responsibility</li><li>Ensuring proper physical receipt and integration of equipment</li><li>Guaranteeing that purchased equipment meets defined performance standards</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Higher education in Mechanical Engineering or similar fields</li><li>Knowledge of factory design layouts</li><li>Knowledge of 2D design (AutoCAD or equivalent)</li><li>Knowledge of 3D design (SolidWorks, Catia, Inventor, etc.) is a plus</li><li>Experience in internal factory logistics flows</li><li>Knowledge of automation (conveyors, robots, gantries, etc.)</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965265,"hash":"L394V6YW","position_name":"Informatica PowerCenter Developer (Insurance Sector)","description":"<p><strong>Job position: Informatica PowerCenter Developer for Insurance Sector<br><br>Location: ﻿Remote Work from Portugal (priority to candidates that can be in Lisbon&nbsp; client's office 3dpw)</strong>﻿</p>\n<p></p>\n<p>PTC Group is recruiting for a digital consultancy and technology services provider that offers edge-to-core solutions to help organizations achieve the full potential of AI-driven digital transformation. Utilizing a technology-unified operating model for cloud, data, and IoT, this company delivers end-to-end value creation for clients through innovation in digital engineering, implementation services, products, and solutions.﻿</p>\n<p></p>\n<p>﻿<strong><strong>Responsibilities and Tasks of the Job</strong></strong>﻿</p>\n<p>The Informatica Developer will be primarily responsible for developing and supporting ETL code in Informatica PowerCenter for an enterprise data warehouse. As per this position expectations,&nbsp;<strong>candidates should be working on new informatica power center application installation or upgrade the present Informatica application from 10.4.1 to 10.5.5 version, code migration from lower environments to higher environments.</strong></p>\n<ul><li>Develop new ETL and enhancements and modify existing code using Informatica PowerCenter. Work independently to develop, configure, and unit test programs from specs (source to target mappings).</li><li>Work closely with data architects, reporting team and application team on ETL development efforts.</li><li>Design and document ETL solutions for projects, estimate work effort and provide status of tasks.</li><li>Provide technical support for the administration and production support of Informatica.</li><li>Provide first and second level troubleshooting, and baseline and operational support.</li><li>Adhere to best practices and methodologies for ETL development team.</li><li>Present all work in design and code review sessions to senior team members.</li><li>Prepare documents that describe, and support code developed.</li><li>Identify improvements to the data warehouse environment. Work with the team to implement these solutions.</li><li>Escalate issues to the right party when required.</li></ul>\n<p></p>\n<p><strong><strong><strong>Mandatory Skills</strong></strong></strong></p>\n<ul><li>10+ years of hands-on experience in ETL development for a data warehouse.</li><li>10+ years of hands-on experience in development, maintenance, and enhancements of Informatica Mappings, Workflows, and processes.</li><li>8+ years of leadership experience, includes the management and coordination of an Informatica team.</li><li>Has experience working with complex SQL.</li><li>Expertise with integration technologies and processes.</li><li>Has Query Surge experience.</li><li>Candidate has window environment experience.</li><li>Possess knowledge of testing tools and techniques.</li><li>Has a working knowledge of Kimball design methodology.</li><li>Fluency in English is mandatory.﻿</li></ul>\n<p></p>\n<p><strong><strong>Complementary Skills</strong></strong><br></p>\n<ul><li>Excellent analytical, organization, presentation, and facilitation skills.</li><li>Possess the ability to handle multiple tasks under tight deadlines.</li></ul>\n<p></p>\n<p><strong>Eduaction requirements</strong></p>\n<ul><li>Bachelor's degree in Computer Science, MIS, related field, or equivalent experience.</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:42 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=12
@@ -718,11 +718,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:57 GMT
+      - Tue, 30 Jul 2024 16:28:43 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '44321'
+      - '27979'
       Connection:
       - keep-alive
       Server:
@@ -743,8 +743,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=13","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=11","results":[{"id":1960519,"hash":"L5367743","position_name":"Key User SAP MM","description":"<p>Com mais de 50 anos de história e mais de mil colaboradores, nosso cliente é&nbsp;um grupo considerado hoje um dos maiores no Agronegócio brasileiro, além da atuação nos mercados de Etanol, Portos e Concessionarias<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p>Suporte a Implementação e Mapeamento do SAP MM<br></p>\n<p>\n- Suporte a Configuração do Sistema: Suportar na definição e configuração do módulo SAP MM de acordo com as necessidades específicas do setor, incluindo processos de compras, gestão de estoques e controle de materiais.<br>\n- Mapeamento de Processos: Mapear os processos da empresa para assegurar que as definições do sistema atendam às exigências de negócios agrícolas, como a gestão de insumos agrícolas, máquinas e equipamentos.<br></p>\n<p>Análise de Negócios e Requisitos<br>\n- Levantamento de Requisitos: Entender as necessidades e os processos de agronegócio e traduzi-los em requisitos funcionais e técnicos.<br></p>\n<p>Treinamento e Suporte aos Usuários<br>\n- Treinamento: Desenvolver e conduzir treinamentos para usuários finais e key users sobre o uso e funcionalidades do SAP MM.<br>\n- Suporte Contínuo: Fornecer suporte técnico e funcional contínuo para resolver problemas e garantir a eficiência do sistema.<br></p>\n<p>Melhoria Contínua de Processos<br>\n- Identificação de Melhorias: Analisar continuamente os processos de negócios e identificar oportunidades de melhoria utilizando o SAP MM.<br>\n- Implementação de Melhorias: Implementar e monitorar melhorias nos processos de gestão de materiais e estoques, visando maior eficiência e redução de custos.</p>\n<p>\nTestes e Revisões<br>\n- Testes End-to-End: Realizar testes em todas as transações e tabelas que possam ser impactadas com as mudanças garantir que o sistema e suas interfaces estão se comunicando da maneira correta.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<p>Experiência mínima de 3 anos atuando como key User SAP MM</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Desejável experiência em segmentos de negócio agro (milho, soja, eucalipto, cana)</span><br></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Regime de trabalho - presencial - Curitiba, PR<br>﻿Contratação PJ</p>\n<p><br></p><p><br></p>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"State of Paraná","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, State of Paraná, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1786902,"hash":"QWY663X9","position_name":"Líder de Produção","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. </p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>Experiência mínima de 3 anos com&nbsp;Extrusão.&nbsp;<br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em plásticos, matérias primas e aditivos.</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em PVC&nbsp;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Cuidados com Moldes.</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Pacote Office - básico;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Experiência com gestão de equipe;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em ferramentas de gestão;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Vivência em Indústria</span></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>Desejável: Técnico/Tecnólogo em Extrusão ou Plástico;</p>\n<p></p>","country":"Brazil","state":"SP","city":"Itatiba","address":"","zipcode":"","location_display":"Itatiba, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1843380,"hash":"L64R9YVW","position_name":"Lithium-Ion Battery Training Instructor","description":"<p>PTC Academy is a premier educational institution specializing in delivering top-tier training programs for professionals. We are seeking a dynamic instructor to teach two specialized modules on lithium-ion batteries, focusing on their application in electric vehicles and their fabrication and characterization.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">We are looking for an experienced and knowledgeable instructor to lead two comprehensive modules on lithium-ion batteries:&nbsp;1. Lithium-Ion Battery - Application to Electric Vehicles and 2.Lithium-Ion Batteries: Manufacturing and Characterization.</span></p><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsibilities and Tasks of the Job</strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Provide in-depth instruction on the application of lithium-ion batteries in electric vehicles.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Develop and deliver engaging course content, including lectures, case studies, and practical applications.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Assist students in understanding battery integration, performance, and management systems in electric vehicles.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Teach the principles and practices of lithium-ion battery fabrication and characterization techniques.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Create detailed course materials focusing on battery design, production processes, and performance evaluation.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Guide students through hands-on exercises and projects related to battery fabrication and testing.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Assess trainees learning</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Carry out all registrations on the PTC Academy LMS platform</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Collaborate with the PTC Academy pedagogical team in formalizing all training records</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><strong>Mandatory Skills</strong></strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><strong></strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Bachelors or Masters degree in Electrical Engineering, Chemical Engineering, Materials Science, or a related field.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Extensive experience with lithium-ion battery technology, including practical applications in electric vehicles and battery manufacturing.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Proven teaching or training experience, particularly in a remote or online setting.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Strong ability to communicate complex technical concepts clearly and effectively.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Ability to engage and motivate learners with diverse backgrounds and skill levels.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Fluency in English</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Complementary Skills</strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Knowledge of current trends and advancements in lithium-ion battery technology.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Experience with battery management systems and electric vehicle design.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Familiarity with industry standards and testing protocols for battery characterization.</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>What we offer</strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Competitive remuneration based on experience.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Flexible working hours with remote teaching opportunities.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Opportunity to make a significant impact on professionals careers.</span></li></ul>","country":"Romania","state":"Bucharest","city":"Bucharest","address":"","zipcode":"","location_display":"Bucharest, Bucharest, Romania","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1929651,"hash":"QX3W5V4Y","position_name":"Lubrificador","description":"<p>Junte-se a família PTC Group 🤩<br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙<br></p>\n<p>Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀<br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p>Executar a lubrificação das maquina operatrizes conforme plano de trabalho.</p>\n<p>Segundo grau completo</p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Requisitos :</span><br></p>\n<p>Experiencia com manutenção e lubrificação de maquinas<br></p>\n<p>Disponibilidade para trabalho aos finais de semana em regime de horas extra.</p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Regime de contratação:</span><br></p>\n<p>CLT</p>\n<p></p>\n<p></p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1828802,"hash":"QWY464X6","position_name":"Machining Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Machining Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in industrializing parts in 4 Axis Palletized Horizontal Machining Centers:<br>- Validation of cutting tools<br>- Validation of part clamping assemblies<br>- Realization of CNC programs Siemens 840 (ISO); G code.<br>- Centering the machining process<br>- Realization of capabilities</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1843342,"hash":"L4Y65935","position_name":"Matlab Trainer","description":"<p>PTC Academy is a leading provider of cutting-edge educational programs, dedicated to empowering professionals through practical and engaging training. We are expanding our team to include expert trainers who can deliver high-quality instruction in MATLAB simulation.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿We are seeking a knowledgeable and experienced MATLAB Simulation Trainer to lead three specialized courses: MATLAB Simulation Introduction, Advanced MATLAB Simulation, and Simulation MATLAB Simulink Stateflow. The ideal candidate will have a strong background in MATLAB and Simulink, coupled with excellent teaching skills.</span></p><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsibilities and Tasks of the Job</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Deliver foundational instruction in MATLAB for simulation</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Develop course materials and hands-on exercises</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Guide students through introductory projects and simulations</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Assess trainees learning</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Carry out all registrations on the PTC Academy LMS platform</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿Collaborate with the PTC Academy pedagogical team in formalizing all training records</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><strong>Mandatory Skills</strong>﻿</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Bachelors or Masters degree in Engineering, Computer Science, or a related field.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Proven experience with MATLAB and Simulink, including hands-on project development.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Previous teaching or training experience, ideally in a remote or online setting.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Strong communication and presentation skills.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Ability to engage and motivate learners with diverse backgrounds and skill levels.﻿</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Complementary Skills</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Experience with MATLAB toolboxes and additional features.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Familiarity with real-world applications of MATLAB in industry.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Certification in MATLAB or Simulink is a plus.</span></li></ul><p><strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></strong></p><p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>What we offer</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Competitive remuneration based on experience.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Flexible working hours with remote teaching opportunities.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Opportunity to make a significant impact on professionals careers.﻿</span></li></ul>","country":"Romania","state":"Bucharest","city":"Bucharest","address":"","zipcode":"","location_display":"Bucharest, Bucharest, Romania","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852751,"hash":"QX3846YR","position_name":"Network Engineer","description":"<p>A PTC Group está à procura de um Network Engineer / Enginheiro de Redes para um cliente do sector bancário&nbsp;líder em Portugal,&nbsp;especializado em Cisco para configurar, manter e otimizar a infraestrutura de rede. Requisitos incluem sólidos conhecimentos em TCP/IP, experiência com equipamentos Cisco, formação em Tecnologia da Informação e certificações como CCNA. Conhecimentos em virtualização, cloud computing e sistemas de armazenamento serão valorizados.&nbsp;<br></p><p></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p><ul><li>Configurar routers e switches Cisco, sob supervisão, garantindo a segmentação de rede VLAN bem como a&nbsp;conectividade básica.﻿</li><li>Utilizar ferramentas como Cisco para monitorizar a performance da rede, identificar problemas e reportar anomalias à equipa.</li><li>Tarefas de NOC, fornecer suporte técnico de primeira linha, realizar diagnósticos básicos e resolver problemas de conectividade simples, e escalar problemas&nbsp;quando necessário.</li><li>﻿﻿Auxiliar na configuração de firewalls Cisco para VPNs e aplicar políticas de segurança sob a orientação dos protocolos da equipa.</li><li>Manter documentação atualizada das configurações de dispositivos e mudanças na rede.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br>\n</p><ul><li>Licenciatura em Ciências da Computação/Redes/Sistemas de Informação</li><li>Mínimo de 3 anos de experiência profissional na área de redes e segurança</li><li>Experiência em implementar, gerir e monitorizar, gestão dispositivos de infraestrutura de rede Cisco, incluindo pontos de acesso e controladores sem fios, routers, switches (LAN e Core) e dispositivos de segurança</li><li>Experiência em manutenção e&nbsp;suporte de produtos e infraestruturas LAN, WAN, WLAN</li><li>Experiência no design e implementação de redes WAN/LAN/WIFI, MPLS, SDN e DataCenter</li><li>Formação/Certificação Cisco: CCNA, CCNP, CCIE</li><li><p>Conhecimento de inglês é valorizado</p></li></ul>\n<p><strong><strong>O que oferecemos</strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong>﻿</strong></p><p></p><ul><li>Remuneração compatível com a função e seguro de saúde.</li><li>Integração numa empresa em constante crescimento.</li></ul>","country":"Portugal","state":"Lisbon","city":"Oeiras","address":"","zipcode":"","location_display":"Oeiras, Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1727118,"hash":"L4738457","position_name":"New Business Development","description":"<p></p>\n<p><span dir=\"ltr\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\">Somos uma multinacional de Engenharia e TI</strong><span style=\"font-family: inherit; font-size: 0.875rem;\">, constituída por uma equipa versátil e movida pela busca incessante da excelência e inovação em todas as nossas iniciativas.</span></p>\n<p><strong>Somos globais! </strong>A PTC Group está presente em todo o mundo, proporcionando uma proximidade inigualável aos nossos clientes.</p>\n<p>Como fornecedor global de serviços de engenharia, tecnologia e consultoria, estamos estrategicamente posicionados para impulsionar as suas ambições e preparar o seu negócio para o futuro.</p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></strong></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><ul><li>Desenvolver carteira de clientes com foco na área automotiva;</li><li>Preparar propostas comerciais alinhadas com as necessidades de cada cliente;</li><li>Poder de negociação de valor e não preço;</li><li>Responsável pela satisfação destes clientes;</li><li>Manter CRM HUBSPOT atualizado para facilitar as tomadas de decisão.</li></ul>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Obrigatórios</strong></strong><br></p><ul><li>Formação em Engenharia;</li><li>Disponibilidade para viagem;</li><li>Inglês nível intermediário;</li><li>Conhecimento de Excel;</li><li>Organização;</li><li>Experiência anterior com venda de produtos e serviços técnicos.</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p><ul><li>Inglês nível avançado;</li><li>Domínio de Power BI.<strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong></li></ul>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"Santo André","address":"","zipcode":"","location_display":"Santo André, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1658319,"hash":"L57354WR","position_name":"Office Assistant","description":"<p>Our client is a leading strategic consulting firm specializing in public affairs. Based in Spain, Portugal, and Brussels.</p>\n<p>We are currently seeking an <strong>Office Assistant</strong> for the <strong>Brussels office</strong> (located next to the Parliament).</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Position located at the reception desk (handling visitors, clients, and suppliers).&nbsp;</li><li>Managing the agenda of the assigned director.\nCoordinating with other Office Assistants in the other offices (Madrid, Barcelona, and Lisbon).&nbsp;</li><li>Drafting, processing, and organizing postal or electronic correspondence.&nbsp;</li><li>Meeting rooms (preparation, organization, supervision).&nbsp;</li><li>Managing travel arrangements, restaurant reservations, hotels, and other logistical needs of the team in coordination with an external agency.&nbsp;</li><li>Organizing and managing corporate events and meetings.&nbsp;</li><li>Organization and coordination of catering.&nbsp;</li><li>Receiving and directing phone calls.\nExpense management.&nbsp;</li><li>Managing corporate materials for clients, suppliers, and the team.&nbsp;</li><li>Drafting, controlling, and monitoring internal procedures.</li><li>\nSupporting various teams in associated tasks.</li></ul>\n<p><strong>Education</strong>:\nMid-level degree.</p>\n<p><strong>Languages</strong> (mandatory):\nNative Spanish.\nEnglish C1.\nFrench (professional level).</p>\n<p>We are looking for a self-motivated individual with a high degree of discretion and confidentiality, ability to work in a team, good communication skills, and a strong desire to build a career within a growing company.</p>","country":"Belgium","state":"Brussels","city":"Brussels","address":"","zipcode":"","location_display":"Brussels, Brussels, Belgium","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933688,"hash":"QY4XRV59","position_name":"Operador de Jato Granalha","description":"<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">A PTC Group é uma multinacional de Engenharia e Tecnologia da Informação com 17 anos no mercado e presente em mais de 14 países focada em Inovação e Outsourcing. Com o propósito de impulsionar a competitividade dos nossos clientes através das nossas soluções personalizadas em todos os principais setores: industrial, automotivo, aeroespacial e defesa, energia, ciências da vida e ferroviário.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\">﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Regime de Contratação: CLT <strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">(INICIALMENTE CONTRATO DE 3 MESES)</strong>﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Modelo de Trabalho: Presencial (Taubaté - SP)<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Horário de Trabalho: 1º Turno ( 05:50/15:38 - Segunda a Sexta-Feira)<br>﻿&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;2º Turno (15:28/00:51 - Segunda a Sexta-Feira)<br>﻿&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;3º Turno (22:10/06:00 - Segunda a Sexta-Feira)</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Benefícios: ﻿﻿Refeitório no local, Ajuda de Custo (Combustível)/Fretado, Assistência Médica Unimed Nacional(Opcional com desconto de coparticipação e mensalidade), Assistência Odontológica Odontoprev (Opcional) e Seguro de vida.</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">REQUISITOS:</strong>﻿</p>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">﻿﻿Ensino Médio Completo;</li></ul>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">NR11 Operador de Empilhadeira e Ponte Rolante.﻿</li></ul>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">CNH ativa e válida.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></li></ul>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">ATRIBUIÇÕES/RESPONSABILIDADES:</strong></p>\n<p>Realizar preparação e operação de jato manual e automática de peças simples e médias, jateando peças e materiais, conforme necessidade da produção.</p>\n<p>Abastecer e operar a cabine de jato; Fazer medição e controle da rugosidade das peças jateadas; Executar outras atividades correlatas.</p>\n<p>Movimentação de carga com Empilhadeira e ponte rolante, tais como moldes e peças correlacionadas.</p>\n<p><br></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:57 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=13","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=11","results":[{"id":1805043,"hash":"L53RV3VR","position_name":"Ingeniero de Proyectos","description":"<p>Nuestro cliente es una importante empresa minorista fabricante de colchones&nbsp;incluidos todos sus componentes, muebles, accesorios y equipos relacionados.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Estamos en busca de un/a ingeniero/a o arquitecto/a para unirse al equipo y liderar la expansión comercial de la empresa. El candidato seleccionado será responsable de la supervisión y ejecución de las obras de los&nbsp;nuevos locales comerciales.</span></p>\n<h3>Responsabilidades:</h3>\n<ul><li><strong>Planificación y coordinación</strong> de proyectos de construcción en nuevos locales.</li><li><strong>Supervisión de la ejecución</strong> de obras para asegurar que se cumplan los plazos y presupuestos establecidos.</li><li><strong>Colaboración con otros departamentos</strong> para garantizar que los nuevos locales cumplan con los estándares de la empresa.</li><li><strong>Gestión de licencias y permisos</strong> necesarios para la realización de las obras.</li><li><strong>Realización de informes periódicos</strong> sobre el estado de los proyectos.</li></ul>\n<h3>Requisitos:</h3>\n<ul><li><strong>Título universitario</strong> en Ingeniería o Arquitectura.</li><li><strong>Experiencia mínima de 3 años</strong> en proyectos de construcción o expansión comercial.</li><li><strong>Conocimientos en normativas y regulaciones</strong> de construcción.</li><li><strong>Habilidad para trabajar en equipo</strong> y coordinar múltiples proyectos simultáneamente.</li><li><strong>Excelentes habilidades de comunicación y organización</strong>.</li><li><strong>Nivel de inglés medio-alto</strong>.</li></ul>\n<h3>¿Qué ofrecemos?:</h3>\n<ul><li>Un <strong>ambiente de trabajo dinámico y colaborativo</strong>.</li><li><strong>Oportunidades de crecimiento y desarrollo profesional</strong>.</li><li><strong>Salario competitivo</strong> acorde a la experiencia y formación del candidato.</li><li><strong>Beneficios adicionales</strong>.</li></ul>\n<p>Si cumples con los requisitos y estás interesado en formar parte del equipo no dudes en apuntarte a la oferta&nbsp;¡Esperamos conocerte!</p>","country":"Spain","state":"CT","city":"Barcelona","address":"","zipcode":"","location_display":"Barcelona, CT, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965160,"hash":"LR453V8R","position_name":"Integration Architect","description":"<p>PTC Group is recruiting a Integration Architect&nbsp;to strengthen our team, working remotely.<br>This Integration Architect will be responsible for:</p>\n<p><strong><strong>Responsabilities:</strong></strong></p>\n<ul><li>Collaborate with data analysts to document integration requirements and current applications, developing future state high-level design documentation.</li><li>Design high-level and low-level integration solutions, ensuring they address all use cases and consider existing reporting and analytics needs.</li><li>Create enterprise reporting solutions that integrate data for blended analysis and propose design phases for transitioning to future states while maintaining existing services.</li><li>Develop new integrations to support evolving business use cases, aligning with organizational strategies and technical standards.</li></ul>\n<ul></ul>\n<p><strong><strong>Requirements:</strong></strong></p>\n<ul><li>Bachelor's degree in Computer Science, Information Technology, or a related field, with relevant certifications such as Azure Solutions Architect or TOGAF considered a plus.</li><li>Extensive experience as an Integration Architect with a strong understanding of integration patterns and proficiency in Azure services, including Azure Functions, API Management, Event Grid, SignalR, Storage Accounts, Azure AD authentication, Managed Identities, Cognitive Services, Event Hub, IoT Hub, and Azure SDK.</li><li>Demonstrated ability to document current systems and design both high-level and low-level integration architectures, coupled with strong problem-solving skills and attention to detail.</li><li>Excellent communication and collaboration abilities, with experience using Visual Studio Professional, and familiarity with RESTful APIs, SOAP, and microservices architecture.</li></ul>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959734,"hash":"L86VRX73","position_name":"Jira Administrator","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um Jira Administrator para reforçar a equipa, em regime remoto.</span></p>\n<p>Este Administrator&nbsp;será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Aplicar atualizações de software e realizar backups regulares para assegurar a segurança e a estabilidade do sistema Jira.</li><li>Fornecer suporte técnico para resolver problemas dos utilizadores e oferecer formação sobre o uso eficiente do Jira.</li><li>Criar e configurar novos projetos e fluxos de trabalho, ajustando as configurações conforme as necessidades da organização.</li><li>Elaborar um plano de migração, realizar backups, transferir dados e testar a nova instância para garantir uma transição suave.</li><li>Implementar melhorias com base no feedback dos utilizadores e fornecer suporte contínuo e eficácia da nova instância do Jira.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +2 anos como Jira Administrator.</li><li>Conhecimentos de ferramentas Office (Excel, Word, Acess)</li><li>Conhecimentos de SQL, Java (Groovy) e JavaScript (JSON) (nice-to-have).</li><li>Conhecimentos em outras ferramentas Atlassian (Confluence) (nice-to-have).</li><li>Conhecimentos de ERPs, CRMs e UI Paths (nice-to-have).</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1946519,"hash":"L53X6885","position_name":"Junior Sales Representative - Engineering Services","description":"<p><span dir=\"ltr\"></span></p>\n<p><strong>Job Title:</strong> Junior Sales Representative - Engineering Services</p>\n<p><strong>Location:</strong> Galicia Region</p>\n<p><strong>Job Summary: </strong>We are seeking a proactive and motivated Junior Sales Representative to support the expansion of our engineering services in the Galicia Region. This role is ideal for an entry-level professional looking to develop their career in sales, focused on engineering services.</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Support the sales team in identifying and prospecting new clients in the Galicia Region.</li><li>Maintain and develop relationships with existing clients.</li><li>Assist in preparing commercial proposals and negotiating contracts.</li><li>Collaborate with the technical team to ensure customer satisfaction and delivery of engineering solutions.</li><li>Update and manage the CRM with relevant information about clients and sales opportunities.</li></ul>\n<p><strong>Requirements:</strong></p>\n<ul><li>Degree in Engineering, Business Administration, Marketing, or a related field.</li><li>Previous experience in sales or customer service is a plus.</li><li>Excellent communication skills and ability to build strong relationships.</li><li>Proactivity, determination, and a desire to learn and grow in sales.</li><li>Willingness to travel within the Galicia Region.</li><li>Languages: Spanish and English.</li></ul>\n<p></p>","country":"Spain","state":"","city":"Galicia","address":"","zipcode":"","location_display":"Galicia, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1946512,"hash":"LR43599R","position_name":"KAM Engineering Services","description":"<p><span dir=\"ltr\" data-redactor-span=\"true\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\">Job Title:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\"> KAM Engineering Services</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\">Location:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\"> Spain</span></p>\n<p><strong>Job Summary: </strong>We are looking for an experienced Key Account Manager (KAM) to manage and develop key accounts across various engineering sectors. This professional will be responsible for strengthening client relationships and driving revenue growth.</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Manage a portfolio of key accounts, ensuring high levels of customer satisfaction and retention.</li><li>Develop strategies to identify and capitalize on new business opportunities in engineering services.</li><li>Collaborate with project teams to ensure successful delivery of engineering solutions.</li><li>Negotiate contracts and commercial terms with clients.</li><li>Stay updated on market trends and competition, adjusting strategies as necessary.</li><li>Produce regular performance reports and sales forecasts for management.</li></ul>\n<p><strong>Requirements:</strong></p>\n<ul><li>Bachelor's degree in Engineering, Business Administration, or a related field.</li><li>Minimum of 3-5 years of experience as a KAM in engineering services.</li><li>Excellent communication, negotiation, and relationship-building skills.</li><li>Ability to work independently and in a team environment.</li><li>Willingness to travel frequently.</li><li>Languages: Spanish and English.</li></ul>\n<p></p>","country":"Spain","state":"Municipality of Vigo","city":"Vigo","address":"","zipcode":"","location_display":"Vigo, Municipality of Vigo, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1946499,"hash":"QX3WX84Y","position_name":"KAM Engineering Services - Railway Sector - Spain","description":"<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Job Title:</strong><span style=\"font-family: inherit; font-size: 0.875rem;\"> Key Account Manager (KAM) - Engineering Services, Railway Sector</span></p>\n<p><strong>Location:</strong> Spain</p>\n<p><strong>Job Summary:</strong>\nWe are seeking a highly qualified Key Account Manager (KAM) to lead and manage our key accounts in the railway sector. The ideal candidate will have extensive experience in railway engineering services, with exceptional relationship management skills and the ability to identify and exploit new business opportunities.</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Manage and develop key accounts in the railway sector, ensuring customer satisfaction and business growth.</li><li>Identify new business opportunities and develop strategies to expand the company's presence in the railway market.</li><li>Negotiate contracts and commercial agreements, securing advantageous terms for both parties.</li><li>Monitor and analyze market trends in the railway sector, adapting strategies accordingly.</li><li>Prepare and present performance reports and sales forecasts to senior management.</li></ul>\n<p><strong>Requirements:</strong></p>\n<ul><li>Bachelor's degree in Engineering, Business Administration, or a related field.</li><li>Minimum of 5 years of experience in a similar role within the railway sector.</li><li>Excellent communication and negotiation skills.</li><li>Ability to work independently and as part of a team.</li><li>Willingness to travel as required.</li><li>Languages: Spanish and English.</li></ul>","country":"Spain","state":"","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1957332,"hash":"L649R54W","position_name":"Key Account Manager Executive Search","description":"<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Junte-se a família PTC Group </font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. </font></font><br></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Somos uma multinacional, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. </font></font><br></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsabilidades e Tarefas da Função</font></font></strong></strong></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Desenvolver carteira de clientes com foco em Executive Search;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Preparar propostas comerciais alinhadas com as necessidades de cada cliente;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Poder de negociação de valor e não preço;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Responsável pela satisfação destes clientes;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Manter CRM HUBSPOT atualizado para facilitar as tomadas de decisão.</font></font></li></ul>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Obrigatórios</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Experiência de 5 anos ou mais no setor;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Disponibilidade para viagem;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Conhecimento de Excel;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Organização;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Boa capacidade de comunicação verbal e escrita;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Perfil mais Hunter do que Farmer.</font></font></li></ul>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Requisitos Complementares</font></font></strong></strong><br></p>\n<ul><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Domínio de Power BI;</font></font></li><li><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">10 anos de experiência na função.</font></font></li></ul>\n<p></p>\n<p><strong><strong><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">O que oferecemos</font></font></strong></strong><br><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Salário fixo;</font></font></p><p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\"></font></font><span style=\"font-family: inherit; font-size: 0.875rem;\">Renda Variável sobre as vendas realizadas;</span></p>\n<p><font style=\"vertical-align: inherit;\"><font style=\"vertical-align: inherit;\">Trabalho híbrido: segundas feiras no escritório e restante da semana trabalho remoto.</font></font></p>\n<p></p>","country":"Brazil","state":"","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1960519,"hash":"L5367743","position_name":"Key User SAP MM","description":"<p>Com mais de 50 anos de história e mais de mil colaboradores, nosso cliente é&nbsp;um grupo considerado hoje um dos maiores no Agronegócio brasileiro, além da atuação nos mercados de Etanol, Portos e Concessionarias<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p>Suporte a Implementação e Mapeamento do SAP MM<br></p>\n<p>\n- Suporte a Configuração do Sistema: Suportar na definição e configuração do módulo SAP MM de acordo com as necessidades específicas do setor, incluindo processos de compras, gestão de estoques e controle de materiais.<br>\n- Mapeamento de Processos: Mapear os processos da empresa para assegurar que as definições do sistema atendam às exigências de negócios agrícolas, como a gestão de insumos agrícolas, máquinas e equipamentos.<br></p>\n<p>Análise de Negócios e Requisitos<br>\n- Levantamento de Requisitos: Entender as necessidades e os processos de agronegócio e traduzi-los em requisitos funcionais e técnicos.<br></p>\n<p>Treinamento e Suporte aos Usuários<br>\n- Treinamento: Desenvolver e conduzir treinamentos para usuários finais e key users sobre o uso e funcionalidades do SAP MM.<br>\n- Suporte Contínuo: Fornecer suporte técnico e funcional contínuo para resolver problemas e garantir a eficiência do sistema.<br></p>\n<p>Melhoria Contínua de Processos<br>\n- Identificação de Melhorias: Analisar continuamente os processos de negócios e identificar oportunidades de melhoria utilizando o SAP MM.<br>\n- Implementação de Melhorias: Implementar e monitorar melhorias nos processos de gestão de materiais e estoques, visando maior eficiência e redução de custos.</p>\n<p>\nTestes e Revisões<br>\n- Testes End-to-End: Realizar testes em todas as transações e tabelas que possam ser impactadas com as mudanças garantir que o sistema e suas interfaces estão se comunicando da maneira correta.</p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong></p>\n<p>Experiência mínima de 3 anos atuando como key User SAP MM</p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Desejável experiência em segmentos de negócio agro (milho, soja, eucalipto, cana)</span><br></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Complementares</strong></strong><br></p>\n<p>Regime de trabalho - presencial - Curitiba, PR<br>﻿Contratação PJ</p>\n<p><br></p><p><br></p>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"State of Paraná","city":"Curitiba","address":"","zipcode":"","location_display":"Curitiba, State of Paraná, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1786902,"hash":"QWY663X9","position_name":"Líder de Produção","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. </p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br>Experiência mínima de 3 anos com&nbsp;Extrusão.&nbsp;<br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em plásticos, matérias primas e aditivos.</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em PVC&nbsp;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Cuidados com Moldes.</span></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Pacote Office - básico;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Experiência com gestão de equipe;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Conhecimento em ferramentas de gestão;<br>﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Vivência em Indústria</span></p>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>Desejável: Técnico/Tecnólogo em Extrusão ou Plástico;</p>\n<p></p>","country":"Brazil","state":"SP","city":"Itatiba","address":"","zipcode":"","location_display":"Itatiba, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1843380,"hash":"L64R9YVW","position_name":"Lithium-Ion Battery Training Instructor","description":"<p>PTC Academy is a premier educational institution specializing in delivering top-tier training programs for professionals. We are seeking a dynamic instructor to teach two specialized modules on lithium-ion batteries, focusing on their application in electric vehicles and their fabrication and characterization.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">We are looking for an experienced and knowledgeable instructor to lead two comprehensive modules on lithium-ion batteries:&nbsp;1. Lithium-Ion Battery - Application to Electric Vehicles and 2.Lithium-Ion Batteries: Manufacturing and Characterization.</span></p><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsibilities and Tasks of the Job</strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Provide in-depth instruction on the application of lithium-ion batteries in electric vehicles.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Develop and deliver engaging course content, including lectures, case studies, and practical applications.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Assist students in understanding battery integration, performance, and management systems in electric vehicles.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Teach the principles and practices of lithium-ion battery fabrication and characterization techniques.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Create detailed course materials focusing on battery design, production processes, and performance evaluation.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Guide students through hands-on exercises and projects related to battery fabrication and testing.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Assess trainees learning</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Carry out all registrations on the PTC Academy LMS platform</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Collaborate with the PTC Academy pedagogical team in formalizing all training records</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><strong>Mandatory Skills</strong></strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><strong></strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Bachelors or Masters degree in Electrical Engineering, Chemical Engineering, Materials Science, or a related field.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Extensive experience with lithium-ion battery technology, including practical applications in electric vehicles and battery manufacturing.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Proven teaching or training experience, particularly in a remote or online setting.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Strong ability to communicate complex technical concepts clearly and effectively.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Ability to engage and motivate learners with diverse backgrounds and skill levels.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Fluency in English</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Complementary Skills</strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Knowledge of current trends and advancements in lithium-ion battery technology.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Experience with battery management systems and electric vehicle design.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Familiarity with industry standards and testing protocols for battery characterization.</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>What we offer</strong></strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Competitive remuneration based on experience.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Flexible working hours with remote teaching opportunities.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Opportunity to make a significant impact on professionals careers.</span></li></ul>","country":"Romania","state":"Bucharest","city":"Bucharest","address":"","zipcode":"","location_display":"Bucharest, Bucharest, Romania","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:43 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=13
@@ -764,11 +764,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:57 GMT
+      - Tue, 30 Jul 2024 16:28:43 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '34529'
+      - '55730'
       Connection:
       - keep-alive
       Server:
@@ -789,8 +789,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=14","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=12","results":[{"id":1633527,"hash":"QX77WYRY","position_name":"Operador de Jato Granalha","description":"<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">A PTC Group é uma multinacional de Engenharia e Tecnologia da Informação com 17 anos no mercado e presente em mais de 14 países focada em Inovação e Outsourcing. Com o propósito de impulsionar a competitividade dos nossos clientes através das nossas soluções personalizadas em todos os principais setores: industrial, automotivo, aeroespacial e defesa, energia, ciências da vida e ferroviário.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\">﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Regime de Contratação: CLT<span data-redactor-span=\"true\"> </span><strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">(INICIALMENTE CONTRATO DE 3 MESES)</strong>﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Modelo de Trabalho: Presencial (Taubaté - SP)<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Horário de Trabalho: 2º Turno ( 14:20 às&nbsp;23:10 -&nbsp;Sábados Alternados)</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Benefícios: ﻿﻿Refeitório no local, Ajuda de Custo (Combustível), Assistência Médica Unimed Nacional(Opcional com desconto de coparticipação e mensalidade), Assistência Odontológica Odontoprev (Opcional) e Seguro de vida.</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">REQUISITOS:</strong>﻿</p>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">﻿﻿Ensino Médio Completo;</li></ul><ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">NR11  Operador de Empilhadeira e Ponte Rolante.﻿</li></ul>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">CNH ativa e válida.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></li></ul>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">ATRIBUIÇÕES/RESPONSABILIDADES:</strong></p><p class=\"TableParagraph\">Realizar preparação e operação de jato manual e automática de peças simples e médias, jateando peças e materiais, conforme necessidade da produção.</p><p class=\"TableParagraph\"><span style=\"font-size: 0.875rem;\">Abastecer e operar a cabine de jato; Fazer medição e controle da rugosidade das peças jateadas; Executar outras atividades correlatas.</span></p>\n<p class=\"TableParagraph\">Movimentação de carga com Empilhadeira e ponte rolante, tais como moldes e peças correlacionadas.</p><p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\"><br>﻿<br></strong></p>","country":"Brazil","state":"SP","city":"Taubaté","address":"","zipcode":"","location_display":"Taubaté, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1655467,"hash":"L5736VR3","position_name":"Program Manager","description":"<p><p>Industria do setor automotivo</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p>\n<p>Gestão de projetos de powertrain: objetivos técnicos, planejamento, recursos, budget e desenvolvimento e validação;</p>\n<p>Intergração do powertrain e seus sistemas na plataforma veicular;</p>\n<p>Gestão do programa de atividades das áreas de powertrain e garantir suas entregas técnicas e resultados;</p>\n<p>Preparação de estudos de factibilidade de novos produtos e programas;</p>\n<p>Gestão de descrição técnica, modificações do produto e aprovação;</p>\n<p>Preparação de apresentações de gerenciamento dos programas;</p>\n<p>Acompanhamento, monitoramento e garantir a validação do produto na fase final de desenvolvimento;</p>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br><br>﻿Formação: Engenharia Mecânica, Elétrica ou Produção;</p>\n<p>Experiência em gerenciamento de programas de desenvolvimento de produtos na área automotiva e uso de metodologias de gestão de projetos;</p>\n<p>Experiência em processo de desenvolvimento, descrição técnica e modificação do produto;</p>\n<p>Conhecimento em motores, transmissões, sistemas e componentes de integração veicular;</p>\n<p>Inglês avançado ou fluente;</p>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong><br>﻿﻿Pós-graduação em Gestão de Projetos;</p>\n<p>Conhecimento em metodologias ágeis;</p>\n<p>Conhecimento de métodos de solução de problemas;</p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, seguro de vida, alimentação </p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1963029,"hash":"L394Y5WV","position_name":"Project Manager","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar Project Managers para vários perfis (CyberSecurity, IT, Telco,&nbsp;Finance)&nbsp;para reforçar as nossas equipas, no Porto ou Lisboa.</span><br></p>\n<p>Estes Project Managers serão responsáveis por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer a gestão da informação e dos stakeholders dos projectos.</li><li>Supervisionar e planear tarefas a desenvolver por parte das equipas de projecto.</li><li>Identificar possíveis riscos para a execução dos projectos e desenvolver planos de mitigação dos mesmos.</li><li>Acompanhar todas as fases dos projectos, desde a sua concepção até ao fecho e&nbsp;entrega do mesmo.&nbsp;</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Gestão, Economia, TI, Redes ou similares.</li><li>Experiência mínima de +1 ano na área de Gestão de Projectos.</li><li>Experiência em projectos de em áreas como&nbsp;CyberSecurity, IT, Telco ou&nbsp;Finance.</li><li>Certificações ITIL, PMI, IPMA ou Prince2 (preferencial)</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1833768,"hash":"L64R6X8W","position_name":"Project Manager - Machining & Mechanical Assembly (Aerospace)","description":"<p>For our customer in FRANCE, a company specializing in the supply of parts and sub-assemblies dedicated to the <strong>aerospace </strong>industry, we are looking for a <strong>Project Manager for Machining &amp; Mechanical Assembly.</strong></p>\n<p><strong><br></strong></p>\n<p><strong>GENERAL INFORMATION:</strong></p>\n<ul><li>The candidate must be available to relocate to France (ROUEN) for a medium-term period (&gt;18 months).</li><li>The position may require geographical travel to clients and suppliers (Europe and Morroco).</li><li>The candidate can be from Portugal, France, or Spain.</li></ul>\n<p>The company specializes in:</p>\n<ul><li>Machining, sheet metal work, and assembly of complex metallic parts and sub-assemblies.</li><li>Machining of complex 5-axis parts (up to 12 meters), in aluminum and hard metals.</li><li>Aerospace sheet metal work / boiler-making qualified for Nadcap heat treatment.</li><li>Assembly of aircraft sub-assemblies (structural riveting).</li></ul>\n<p><strong><br></strong></p>\n<p><strong>JOB POSITION</strong></p>\n<ul><li>Participate in defining the project organization: human and material resources, budget, schedule, tasks and milestones, etc.</li><li>Participate in developing the project risk map.</li><li>Define project tracking indicators.</li><li>Ensure the execution of tasks by each project stakeholder under optimal conditions.</li><li>Ensure compliance with the budget allocated to each project line.</li><li>Ensure the delivery of deliverables at each project milestone.</li><li>Conduct project reviews with a specific focus on incurred costs and encountered difficulties.</li><li>Participate in the development of schedules for new projects (FAI/DVI).</li><li>Ensure adherence to these schedules until series production.</li><li>Ensure the start of programming in accordance with defined internal schedules.</li><li>Ensure that technical articles are properly created, MRP configuration is aligned with customer requirements, and FAI/DVI orders are launched properly.</li><li>Ensure timely material and component procurement.</li><li>Monitor the progression of production phases (machining, subcontracting, etc.).</li><li>Alert the Development Management in case of schedule deviations and propose recovery solutions aligned with various departments and customer requirements.</li><li>Support the Quality Management in scheduling necessary actions (FAI/DVI files, approval requests, waiver requests) during initial part production.</li><li>Ensure parts are shipped to the customer according to commitments made.</li><li>Conduct business reviews for new parts (collect and compile all phase cycle times, material purchase parts, surface treatment or component data) and report findings to the Development Management.</li><li>Propose actions to improve product costs and feasibility.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>RESPONSIBILITIES:</strong></p>\n<ul><li>Acts as the primary interface point with the client.</li><li>Acts as the internal \"multi-disciplinary\" interface point between Industry, Development Management, Logistics Management, and Quality Management for monitoring and/or initiating new markets.</li><li>Ensures compliance with the commercial policy.&nbsp;</li><li>Participates in progress review meetings with the client for all new developments and, when necessary, during series production.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>REQUIREMENTS:</strong></p>\n<ul><li>Bachelors degree +2 or Engineering degree.</li><li>3-5 years of working experience ﻿as a project manager or project technician in the same field.</li><li>English is mandatory; French is a plus.</li><li>Knowledge of machining (milling/turning), product process, and mechanical assembly - business relations (Sales).</li><li>Strong problem-solving skills, creativity, and willingness to think outside the box.</li><li>Ability to efficiently manage and communicate with cross-functional teams.</li><li>Exceptional verbal and written communication skills.</li><li>Good negotiation, conflict management, and problem-solving skills.</li><li>Ability to quickly adapt to the client.</li><li>Mandatory Workvisa or EU Citizenship﻿</li></ul>","country":"France","state":"Normandy","city":"Boos","address":"","zipcode":"","location_display":"Boos, Normandy, France","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1785724,"hash":"LR4VYR5R","position_name":"Projetista 2D - Suspensão","description":"<p>Profissional será responsável por projetos 2D de suspensão veicular</p>\n<p>REQUISITOS OBRIGATÓRIOS<br></p>\n<p>Inglês avançado</p>\n<p>Curso superior completo em engenharia mecânica ou áreas afins</p>\n<p>Necessário conhecimento em CATIA V5 e ou NX</p>\n<p>Necessário conhecimentos de GD&amp;T</p>\n<p>REQUISITOS DESEJÁVEIS</p>\n<p>Desejável conhecimento em PLM</p>\n<p>Desejável conhecimento em projetos de suspensão</p>\n<p>MODALIDADE:</p>\n<p>CLT<br>Hibrido em Betim - MG</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1925703,"hash":"QX3VX4RY","position_name":"Projetista Mecânico","description":"<p>Junte-se a família PTC Group </p>\n<p>Estamos sempre a procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. </p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. </p>\n<p><strong>RESPONSABILIDADES E ATRIBUIÇÕES</strong></p>\n<p>Responsável pelo Desenvolvimento e modelamento dos projetos utilizando as ferramentas CATIA V5/V6 Unigraphics NX11, TeamCenter e Codep;</p>\n<p>Análise técnica de engenharia na concepção de novos produtos da engenharia automobilística.</p>\n<p><strong>REQUISITOS E QUALIFICAÇÕES</strong></p>\n<p>Curso superior em mecânica ou áreas correlatas ou curso técnico em ferramentaria, automação, mecânica;</p>\n<p>Cursos de injeção plástica, moldes, Autocad;</p>\n<p>Experiência em Catia V5 e NX;</p>\n<p>Desejável inglês avançado;</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Disponibilidade de atuação híbrido em Betim-MG.</span></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1958017,"hash":"L3948W3W","position_name":"Projetista Mulher","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong>RESPONSABILIDADES E ATRIBUIÇÕES</strong></p>\n<p>Responsável pelo Desenvolvimento e modelamento dos projetos utilizando as ferramentas CATIA V5/V6 Unigraphics NX11, TeamCenter e Codep;</p>\n<p>Análise técnica de engenharia na concepção de novos produtos da engenharia automobilística.</p>\n<p><strong>REQUISITOS E QUALIFICAÇÕES</strong></p>\n<p>Curso superior em mecânica ou áreas correlatas ou curso técnico em ferramentaria, automação, mecânica;</p>\n<p>Cursos de injeção plástica, moldes, Autocad;</p>\n<p>Experiência em Catia V5 e NX;</p>\n<p>Desejável inglês avançado;</p>\n<p>Disponibilidade de atuação híbrido em Betim-MG;</p><p>Vaga exclusiva para mulheres.</p><p><br></p>\n<p></p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1753814,"hash":"QWYX9756","position_name":"Property Manager","description":"<p>Nos encontramos en la búsqueda de ﻿un Responsable de Edificios en el seno del equipo de Operaciones de una importante empresa&nbsp;gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p>\n<p>Este&nbsp;perfil será el responsable de explotación de un paquete de activos, debiendo ejecutar correctamente las&nbsp;siguientes tareas principales:</p>\n<ul><li>Elaborar y controlar el presupuesto de explotación de los activos.</li><li>Evaluar y atender propuestas de mejora de instalaciones procedentes del área de Facility Management.</li><li>Licitación y selección de subcontratistas necesarios para la correcta explotación de los edificios: seguridad, suministros, limpieza, conserjería, jardinería, mantenimiento, etc.</li><li>Contratar y renovar seguros de los edificios.</li><li>Representar ante terceros (juntas, reuniones de propietarios, administraciones públicas, etc.).</li><li>Garantizar el nivel de satisfacción de los inquilinos y desarrollar estrategias para minimizar la tasa de rotación en los alquileres.</li><li>Contribuir a la estrategia de comercialización de los activos.</li><li>Gestionar incidencias (privativas y zonas comunes).</li><li>Controlar y hacer seguimiento de la deuda.</li></ul>\n<p>El perfil reportará directamente al Director de Operaciones de la empresa y tendrá la oportunidad de contribuir en la definición de las líneas de desarrollo y crecimiento del departamento.<br></p>\n<p><strong>Requisitos:</strong><br></p>\n<ul><li>Haber completado estudios en Finanzas, Ingeniería, Economía, Administración y Dirección de Empresas, o campos afines. Se valorará positivamente cualquier formación complementaria relacionada con el puesto.</li><li>Experiencia mínima de 3 años en puestos de responsabilidad asociados a la gestión de activos inmobiliarios, preferiblemente en el ámbito residencial. Se valorará especialmente la experiencia en funciones realizadas directamente en los activos.</li><li>Dominio de herramientas de ofimática.</li><li>Nivel alto de inglés, tanto escrito como hablado.</li></ul>\n<p>Si cumples con los requisitos y estás interesado en formar parte de nuestro equipo, ¡esperamos tu solicitud!</p>\n<p>﻿﻿<br></p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959701,"hash":"QVXV76W8","position_name":"QA Automation Engineer/Tester (JavaScript e Inflecta)","description":"<p>A PTC Group está a recrutar um QA Automation Engineer/Tester para um projecto, na zona do Porto ou Lisboa, em regime híbrido.</p>\n<p>O Automation Engineer&nbsp;será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Criar e manter scripts de teste automatizados usando ferramentas apropriadas para garantir que o software funcione como esperado.</li><li>Executar testes automatizados para identificar defeitos e garantir que as funcionalidades do software estão a funcionar corretamente.</li><li>Rever os resultados dos testes automatizados, identificar falhas e reportar problemas à equipa de desenvolvimento.</li><li>Trabalhar em conjunto com os developers para resolver problemas identificados durante os testes e melhorar a qualidade do software.</li><li>Configurar e assegurar que o ambiente de teste está pronto para a execução dos testes automatizados.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +1 ano de desenvolvimento em JavaScript.</li><li>Experiência mínima de +1 ano com automatização de testes.</li><li>Experiência com ferramentas Inflecta (Spiratest, Rapise)</li></ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1963050,"hash":"QWYWRX59","position_name":"Quality Assurance Tester","description":"<p>A PTC Group está a recrutar um QA para reforçar a nossa equipa, no Porto</p>\n<p>Este Quality Assurance&nbsp;serão responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer a análise e verificação de requisitos.</li><li>Escrever lista de testes a realizar e codificação dos mesmos.</li><li>Integração dos testes codificados para o ciclo de vida de desenvolvimento e de testes.</li><li>Criação de relatório com os resultados dos testes realizados e atuar sobre os mesmos</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, TI ou similar.</li><li>Experiência mínima de +1 ano como Quality Assurance Tester ou&nbsp;Engineer.</li><li>Experiência com integração de testes codificados e testes a requesitos não funcionais.</li><li>Certificações&nbsp;ISTQB,&nbsp;CSTE ou Azure (nice-to-have).</li></ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:57 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=14","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=12","results":[{"id":1929651,"hash":"QX3W5V4Y","position_name":"Lubrificador","description":"<p>Junte-se a família PTC Group 🤩<br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. 💙<br></p>\n<p>Somos uma multinacional de Engenharia & TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. 🚀<br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<p>Executar a lubrificação das maquina operatrizes conforme plano de trabalho.</p>\n<p>Segundo grau completo</p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Requisitos :</span><br></p>\n<p>Experiencia com manutenção e lubrificação de maquinas<br></p>\n<p>Disponibilidade para trabalho aos finais de semana em regime de horas extra.</p>\n<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Regime de contratação:</span><br></p>\n<p>CLT</p>\n<p></p>\n<p></p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1828802,"hash":"QWY464X6","position_name":"Machining Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Machining Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in industrializing parts in 4 Axis Palletized Horizontal Machining Centers:<br>- Validation of cutting tools<br>- Validation of part clamping assemblies<br>- Realization of CNC programs Siemens 840 (ISO); G code.<br>- Centering the machining process<br>- Realization of capabilities</li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Mioveni","address":"","zipcode":"","location_display":"Mioveni, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1843342,"hash":"L4Y65935","position_name":"Matlab Trainer","description":"<p>PTC Academy is a leading provider of cutting-edge educational programs, dedicated to empowering professionals through practical and engaging training. We are expanding our team to include expert trainers who can deliver high-quality instruction in MATLAB simulation.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿We are seeking a knowledgeable and experienced MATLAB Simulation Trainer to lead three specialized courses: MATLAB Simulation Introduction, Advanced MATLAB Simulation, and Simulation MATLAB Simulink Stateflow. The ideal candidate will have a strong background in MATLAB and Simulink, coupled with excellent teaching skills.</span></p><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsibilities and Tasks of the Job</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Deliver foundational instruction in MATLAB for simulation</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Develop course materials and hands-on exercises</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Guide students through introductory projects and simulations</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Assess trainees learning</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Carry out all registrations on the PTC Academy LMS platform</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿Collaborate with the PTC Academy pedagogical team in formalizing all training records</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><strong>Mandatory Skills</strong>﻿</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Bachelors or Masters degree in Engineering, Computer Science, or a related field.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Proven experience with MATLAB and Simulink, including hands-on project development.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Previous teaching or training experience, ideally in a remote or online setting.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Strong communication and presentation skills.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Ability to engage and motivate learners with diverse backgrounds and skill levels.﻿</span></li></ul><p><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Complementary Skills</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Experience with MATLAB toolboxes and additional features.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Familiarity with real-world applications of MATLAB in industry.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Certification in MATLAB or Simulink is a plus.</span></li></ul><p><strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></strong></p><p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>What we offer</strong>﻿</strong></p><ul><li><strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong><span style=\"font-family: inherit; font-size: 0.875rem;\">Competitive remuneration based on experience.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Flexible working hours with remote teaching opportunities.</span></li><li><span style=\"font-family: inherit; font-size: 0.875rem;\"></span><span style=\"font-family: inherit; font-size: 0.875rem;\">Opportunity to make a significant impact on professionals careers.﻿</span></li></ul>","country":"Romania","state":"Bucharest","city":"Bucharest","address":"","zipcode":"","location_display":"Bucharest, Bucharest, Romania","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1852751,"hash":"QX3846YR","position_name":"Network Engineer","description":"<p>A PTC Group está à procura de um Network Engineer / Enginheiro de Redes para um cliente do sector bancário&nbsp;líder em Portugal,&nbsp;especializado em Cisco para configurar, manter e otimizar a infraestrutura de rede. Requisitos incluem sólidos conhecimentos em TCP/IP, experiência com equipamentos Cisco, formação em Tecnologia da Informação e certificações como CCNA. Conhecimentos em virtualização, cloud computing e sistemas de armazenamento serão valorizados.&nbsp;<br></p><p></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p><ul><li>Configurar routers e switches Cisco, sob supervisão, garantindo a segmentação de rede VLAN bem como a&nbsp;conectividade básica.﻿</li><li>Utilizar ferramentas como Cisco para monitorizar a performance da rede, identificar problemas e reportar anomalias à equipa.</li><li>Tarefas de NOC, fornecer suporte técnico de primeira linha, realizar diagnósticos básicos e resolver problemas de conectividade simples, e escalar problemas&nbsp;quando necessário.</li><li>﻿﻿Auxiliar na configuração de firewalls Cisco para VPNs e aplicar políticas de segurança sob a orientação dos protocolos da equipa.</li><li>Manter documentação atualizada das configurações de dispositivos e mudanças na rede.</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br>\n</p><ul><li>Licenciatura em Ciências da Computação/Redes/Sistemas de Informação</li><li>Mínimo de 3 anos de experiência profissional na área de redes e segurança</li><li>Experiência em implementar, gerir e monitorizar, gestão dispositivos de infraestrutura de rede Cisco, incluindo pontos de acesso e controladores sem fios, routers, switches (LAN e Core) e dispositivos de segurança</li><li>Experiência em manutenção e&nbsp;suporte de produtos e infraestruturas LAN, WAN, WLAN</li><li>Experiência no design e implementação de redes WAN/LAN/WIFI, MPLS, SDN e DataCenter</li><li>Formação/Certificação Cisco: CCNA, CCNP, CCIE</li><li><p>Conhecimento de inglês é valorizado</p></li></ul>\n<p><strong><strong>O que oferecemos</strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong></strong>﻿</strong></p><p></p><ul><li>Remuneração compatível com a função e seguro de saúde.</li><li>Integração numa empresa em constante crescimento.</li></ul>","country":"Portugal","state":"Lisbon","city":"Oeiras","address":"","zipcode":"","location_display":"Oeiras, Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1727118,"hash":"L4738457","position_name":"New Business Development","description":"<p></p>\n<p><span dir=\"ltr\"></span><strong style=\"font-family: inherit; font-size: 0.875rem;\">Somos uma multinacional de Engenharia e TI</strong><span style=\"font-family: inherit; font-size: 0.875rem;\">, constituída por uma equipa versátil e movida pela busca incessante da excelência e inovação em todas as nossas iniciativas.</span></p>\n<p><strong>Somos globais! </strong>A PTC Group está presente em todo o mundo, proporcionando uma proximidade inigualável aos nossos clientes.</p>\n<p>Como fornecedor global de serviços de engenharia, tecnologia e consultoria, estamos estrategicamente posicionados para impulsionar as suas ambições e preparar o seu negócio para o futuro.</p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong><br></strong></strong></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<p></p><ul><li>Desenvolver carteira de clientes com foco na área automotiva;</li><li>Preparar propostas comerciais alinhadas com as necessidades de cada cliente;</li><li>Poder de negociação de valor e não preço;</li><li>Responsável pela satisfação destes clientes;</li><li>Manter CRM HUBSPOT atualizado para facilitar as tomadas de decisão.</li></ul>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Requisitos Obrigatórios</strong></strong><br></p><ul><li>Formação em Engenharia;</li><li>Disponibilidade para viagem;</li><li>Inglês nível intermediário;</li><li>Conhecimento de Excel;</li><li>Organização;</li><li>Experiência anterior com venda de produtos e serviços técnicos.</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br></p><ul><li>Inglês nível avançado;</li><li>Domínio de Power BI.<strong style=\"font-family: inherit; font-size: 0.875rem;\"></strong></li></ul>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"Santo André","address":"","zipcode":"","location_display":"Santo André, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1658319,"hash":"L57354WR","position_name":"Office Assistant","description":"<p>Our client is a leading strategic consulting firm specializing in public affairs. Based in Spain, Portugal, and Brussels.</p>\n<p>We are currently seeking an <strong>Office Assistant</strong> for the <strong>Brussels office</strong> (located next to the Parliament).</p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Position located at the reception desk (handling visitors, clients, and suppliers).&nbsp;</li><li>Managing the agenda of the assigned director.\nCoordinating with other Office Assistants in the other offices (Madrid, Barcelona, and Lisbon).&nbsp;</li><li>Drafting, processing, and organizing postal or electronic correspondence.&nbsp;</li><li>Meeting rooms (preparation, organization, supervision).&nbsp;</li><li>Managing travel arrangements, restaurant reservations, hotels, and other logistical needs of the team in coordination with an external agency.&nbsp;</li><li>Organizing and managing corporate events and meetings.&nbsp;</li><li>Organization and coordination of catering.&nbsp;</li><li>Receiving and directing phone calls.\nExpense management.&nbsp;</li><li>Managing corporate materials for clients, suppliers, and the team.&nbsp;</li><li>Drafting, controlling, and monitoring internal procedures.</li><li>\nSupporting various teams in associated tasks.</li></ul>\n<p><strong>Education</strong>:\nMid-level degree.</p>\n<p><strong>Languages</strong> (mandatory):\nNative Spanish.\nEnglish C1.\nFrench (professional level).</p>\n<p>We are looking for a self-motivated individual with a high degree of discretion and confidentiality, ability to work in a team, good communication skills, and a strong desire to build a career within a growing company.</p>","country":"Belgium","state":"Brussels","city":"Brussels","address":"","zipcode":"","location_display":"Brussels, Brussels, Belgium","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1633527,"hash":"QX77WYRY","position_name":"Operador de Jato Granalha","description":"<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">A PTC Group é uma multinacional de Engenharia e Tecnologia da Informação com 17 anos no mercado e presente em mais de 14 países focada em Inovação e Outsourcing. Com o propósito de impulsionar a competitividade dos nossos clientes através das nossas soluções personalizadas em todos os principais setores: industrial, automotivo, aeroespacial e defesa, energia, ciências da vida e ferroviário.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\">﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Regime de Contratação: CLT<span data-redactor-span=\"true\"> </span><strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">(INICIALMENTE CONTRATO DE 3 MESES)</strong>﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Modelo de Trabalho: Presencial (Taubaté - SP)<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Horário de Trabalho: 2º Turno ( 14:20 às&nbsp;23:10 -&nbsp;Sábados Alternados)</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Benefícios: ﻿﻿Refeitório no local, Ajuda de Custo (Combustível), Assistência Médica Unimed Nacional(Opcional com desconto de coparticipação e mensalidade), Assistência Odontológica Odontoprev (Opcional) e Seguro de vida.</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">REQUISITOS:</strong>﻿</p>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">﻿﻿Ensino Médio Completo;</li></ul><ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">NR11  Operador de Empilhadeira e Ponte Rolante.﻿</li></ul>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">CNH ativa e válida.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></li></ul>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">ATRIBUIÇÕES/RESPONSABILIDADES:</strong></p><p class=\"TableParagraph\">Realizar preparação e operação de jato manual e automática de peças simples e médias, jateando peças e materiais, conforme necessidade da produção.</p><p class=\"TableParagraph\"><span style=\"font-size: 0.875rem;\">Abastecer e operar a cabine de jato; Fazer medição e controle da rugosidade das peças jateadas; Executar outras atividades correlatas.</span></p>\n<p class=\"TableParagraph\">Movimentação de carga com Empilhadeira e ponte rolante, tais como moldes e peças correlacionadas.</p><p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\"><br>﻿<br></strong></p>","country":"Brazil","state":"SP","city":"Taubaté","address":"","zipcode":"","location_display":"Taubaté, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1933688,"hash":"QY4XRV59","position_name":"Operador de Jato Granalha","description":"<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">A PTC Group é uma multinacional de Engenharia e Tecnologia da Informação com 17 anos no mercado e presente em mais de 14 países focada em Inovação e Outsourcing. Com o propósito de impulsionar a competitividade dos nossos clientes através das nossas soluções personalizadas em todos os principais setores: industrial, automotivo, aeroespacial e defesa, energia, ciências da vida e ferroviário.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\">﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Regime de Contratação: CLT <strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">(INICIALMENTE CONTRATO DE 3 MESES)</strong>﻿</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Modelo de Trabalho: Presencial (Taubaté - SP)<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Horário de Trabalho: 1º Turno ( 05:50/15:38 - Segunda a Sexta-Feira)<br>﻿&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;2º Turno (15:28/00:51 - Segunda a Sexta-Feira)<br>﻿&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;3º Turno (22:10/06:00 - Segunda a Sexta-Feira)</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿Benefícios: ﻿﻿Refeitório no local, Ajuda de Custo (Combustível)/Fretado, Assistência Médica Unimed Nacional(Opcional com desconto de coparticipação e mensalidade), Assistência Odontológica Odontoprev (Opcional) e Seguro de vida.</p>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">REQUISITOS:</strong>﻿</p>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">﻿﻿Ensino Médio Completo;</li></ul>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">NR11 Operador de Empilhadeira e Ponte Rolante.﻿</li></ul>\n<ul data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em 1.5em; list-style-type: disc !important; color: rgb(51, 51, 51); font-family: Roboto; font-size: 13.86px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\"><li data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; text-align: left;\">CNH ativa e válida.<br data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px;\"></li></ul>\n<p data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px 0px 1em; font-size: 13.86px; line-height: 1.5; font-family: Roboto; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(245, 245, 245); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;\">﻿<strong data-redactor-style-cache=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\" style=\"box-sizing: inherit; background-repeat: no-repeat; padding: 0px; margin: 0px; font-weight: bolder;\">ATRIBUIÇÕES/RESPONSABILIDADES:</strong></p>\n<p>Realizar preparação e operação de jato manual e automática de peças simples e médias, jateando peças e materiais, conforme necessidade da produção.</p>\n<p>Abastecer e operar a cabine de jato; Fazer medição e controle da rugosidade das peças jateadas; Executar outras atividades correlatas.</p>\n<p>Movimentação de carga com Empilhadeira e ponte rolante, tais como moldes e peças correlacionadas.</p>\n<p><br></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1965274,"hash":"QWYWV5RW","position_name":"Production Support Data Analyst (Insurance Sector)","description":"<p><strong>Job position: Production Support Data Analyst for Insurance Sector<br><br>Location: ﻿Remote Work from Portugal (priority to candidates that can be in Lisbon client's office 3dpw)</strong></p>\n<p></p>\n<p>PTC Group is recruiting for a digital consultancy and technology services provider that offers edge-to-core solutions to help organizations achieve the full potential of AI-driven digital transformation. Utilizing a technology-unified operating model for cloud, data, and IoT, this company delivers end-to-end value creation for clients through innovation in digital engineering, implementation services, products, and solutions.﻿</p>\n<p></p>\n<p><strong><strong>Responsibilities and Tasks of the Job</strong></strong>﻿﻿</p>\n<p>The Production Support Data Analyst is a hands-on position with a focus on supporting the data accuracy and completeness within the enterprise data warehouse. The position will work within IT to help Sompo International maintain the enterprise data warehouse architecture. Furthermore, the data warehouse architecture will measure performance in all aspects of the organizations operations.﻿</p>\n<ul><li>Work with business stakeholders and IT teams to analyze and resolve data issues for the enterprise data warehouse.</li><li>Create source-to-target mapping documents to capture additional application data elements.</li><li>Load the source-to-target mapping documents from source systems into the enterprise data warehouse.</li><li>Collaborate with the ETL team to ensure the source-to-target mapping documents are in correct ETL code.</li><li>Ensure the ETL code align with STM requirements.</li><li>Perform data validation, to insure correct data movement into the enterprise data warehouse architecture.</li><li>Consult with reporting teams to develop a general understanding for any identified variances between the enterprise data warehouse and source system applications.</li></ul>\n<p></p>\n<p><strong><strong><strong>Mandatory Skills</strong>﻿</strong>﻿</strong></p>\n<ul><li>Proven 3+ years experience of data analysis within an enterprise data warehouse.</li><li>Possess 2 years of Policy &amp; Claims Insurance subject-matter expertise.</li><li>Candidate has advanced level SQL knowledge.</li><li>Possess optimal knowledge for concepts and frameworks for Data Warehousing, ETL, and BI Architectures.</li><li>Candidate is capable of creating and tuning Semantic layer Reporting Views.</li><li>Able to facilitate data discovery sessions, which will include an audience of business subject-matter experts.</li><li>Proven knowledge of RDBMS platforms (e.g., SQL Server, DB2), with experience in generating DDL.</li><li>Possess knowledge of Guidewire Policy Center, Guidewire Claims Center, SAP FS-RI &amp; SAP FS-CD applications with their data is considered a plus.</li><li>Fluency in English is mandatory.﻿</li></ul>\n<p></p>\n<p><strong><strong>Complementary Skills</strong>﻿</strong><br></p>\n<ul><li>Candidate has strong interpersonal skills, including both written and verbal communication skills.</li><li>Possess the ability to work as part of a team.</li><li>Candidate has strong organizational skills and analysis skills.</li></ul>\n<p></p>\n<p><strong>Education requirements</strong>﻿<br></p>\n<ul><li>B.S. Degree in Computer Information Science, Information Management, or Statistics.﻿</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":true,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1655467,"hash":"L5736VR3","position_name":"Program Manager","description":"<p><p>Industria do setor automotivo</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong><br></p>\n<p>Gestão de projetos de powertrain: objetivos técnicos, planejamento, recursos, budget e desenvolvimento e validação;</p>\n<p>Intergração do powertrain e seus sistemas na plataforma veicular;</p>\n<p>Gestão do programa de atividades das áreas de powertrain e garantir suas entregas técnicas e resultados;</p>\n<p>Preparação de estudos de factibilidade de novos produtos e programas;</p>\n<p>Gestão de descrição técnica, modificações do produto e aprovação;</p>\n<p>Preparação de apresentações de gerenciamento dos programas;</p>\n<p>Acompanhamento, monitoramento e garantir a validação do produto na fase final de desenvolvimento;</p>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong><br><br>﻿Formação: Engenharia Mecânica, Elétrica ou Produção;</p>\n<p>Experiência em gerenciamento de programas de desenvolvimento de produtos na área automotiva e uso de metodologias de gestão de projetos;</p>\n<p>Experiência em processo de desenvolvimento, descrição técnica e modificação do produto;</p>\n<p>Conhecimento em motores, transmissões, sistemas e componentes de integração veicular;</p>\n<p>Inglês avançado ou fluente;</p>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong><br>﻿﻿Pós-graduação em Gestão de Projetos;</p>\n<p>Conhecimento em metodologias ágeis;</p>\n<p>Conhecimento de métodos de solução de problemas;</p>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, seguro de vida, alimentação </p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:44 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=14
@@ -810,11 +810,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:58 GMT
+      - Tue, 30 Jul 2024 16:28:44 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '21923'
+      - '20521'
       Connection:
       - keep-alive
       Server:
@@ -835,8 +835,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=15","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=13","results":[{"id":1962533,"hash":"L7696885","position_name":"Red Hat Enterprise Linux Engineer","description":"<p><strong>We are looking for a&nbsp;Red Hat Enterprise Linux Engineer to join PTC Group in one of our projects in Porto.</strong></p>\n<p><strong>The candidate to be chosen must be 100% on-premises during the first 2 or 3 months (time of successful onboarding). After, we have a working policy of 3 days in the office and 2 remote. Of course, the candidate can work 100% at our facilities after the onboarding process.</strong></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Job Profile</strong><br></p>\n<ul>\n <li>Manage,      configure, upgrade and troubleshoot Linux servers in stand-alone or      clustered environments using automation.</li>\n <li>Manage,      configure, upgrade and troubleshoot Storage Servers and SAN Switches.</li>\n <li>Manage,      configure, upgrade and troubleshoot Vmware Servers.</li>\n <li>Interact      with other teams to fully understand and implement business requirements,      security policies, compliance rules and network connectivity flows.</li>\n</ul>\n<p><strong>Key Accountabilities</strong></p>\n<ul>\n <li>Ensure      that Linux servers have the appropriated availability, performance and      security that our business requires.</li>\n <li>Ensure      that every addition, removal or change done on the Linux servers is      properly managed through our automation platform.</li>\n <li>Ensure      that security policies and compliance rules are applied in the Linux      servers.</li>\n</ul>\n<p><strong>Knowledge, Skills and Experience Required</strong></p>\n<ul>\n <li>5+      years of experience in Linux systems administration.</li>\n <li>Experience      with Linux clustering.</li>\n <li>Experience      with automation.</li>\n <li>Experience      with Vmware.</li>\n <li>Experience      with Storage Servers.</li>\n <li>Demonstrated      knowledge of infrastructure services and networking topologies.</li>\n <li>Strong      organizational, multi-tasking, and time-management skills.</li>\n <li>Good      communication and interpersonal skills.</li>\n <li>Good      English communication skills (written and oral).</li>\n <li>Ability      to learn and apply new concepts quickly.</li>\n <li>Team      player.</li>\n</ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1962530,"hash":"L4Y5Y99V","position_name":"Red Hat OpenShift Engineer","description":"<p><strong>We are looking for a Red Hat OpenShift Engineer to join PTC Group in a project in Porto.&nbsp;<br></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\">The candidate to be chosen must be 100% on-premises during the first 2 or 3 months (time of successful onboarding). After, we have a working policy of 3 days in the office and 2 remote. Of course, the candidate can work 100% at our facilities after the onboarding process.</strong></p>\n<p><strong><br></strong></p>\n<p><strong>Job Profile</strong></p>\n<ul>\n <li>Manage,      configure, upgrade and troubleshoot Red Hat OpenShift infrastructure.</li>\n <li>Manage,      configure, upgrade and troubleshoot Storage Servers and SAN Switches.</li>\n <li>Interact      with other teams to fully understand and implement business requirements,      security policies, compliance rules and network connectivity flows.</li>\n</ul>\n<p><strong>Key Accountabilities</strong></p>\n<ul>\n <li>Ensure      that OpenShift infrastructure have the appropriated availability,      performance and security that our business requires.</li>\n <li>Ensure      that every addition, removal or change done on the OpenShift      infrastructure is properly managed through our automation platform.</li>\n <li>Ensure      that security policies and compliance rules are applied in the OpenShift      infrastructure.</li>\n</ul>\n<p><strong>Knowledge, Skills and Experience Required</strong></p>\n<ul>\n <li>5+      years of experience in OpenShift administration.</li>\n <li>System      administration, conceptualization, design, construction, and operation of      OpenShift platforms.</li>\n <li>Experience      with Red Hat Enterprise Linux (RHEL) and CI/CD tools.</li>\n <li>Experience      with automation.</li>\n <li>Experience      with Storage Servers.</li>\n <li>Demonstrated      knowledge of infrastructure services and networking topologies.</li>\n <li>Strong      organizational, multi-tasking, and time-management skills.</li>\n <li>Good      communication and interpersonal skills.</li>\n <li>Good      English communication skills (written and oral).</li>\n <li>Ability      to learn and apply new concepts quickly.</li>\n <li>Team      player.</li>\n</ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1688145,"hash":"L773VR43","position_name":"Referente Técnico - Sistemas Eletroeletrônicos (Chicotes e Distribuição)","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong></p>\n<ul><li><strong></strong>Garantir a sinergia entre as soluções técnicas aplicadas nos subsistemas de eletrônicos embarcados, levando&nbsp;em conta a robustez, o atendimento de requisitos, materiais, objetivos de performance, custo, normas técnicas, planos de padronização, melhores práticas, lições aprendidas, dentre outras.&nbsp;</li><li>Responsável pela divulgação e cumprimento da especificação dos componentes durante o desenvolvimento de novos produtos e de série.</li><li>Garantir o design, prototipação, instalação,&nbsp;release e documentação técnica do produto&nbsp;</li><li>Desenvolvimento de fornecedores﻿﻿</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong></p>\n<ul><li>Formação em Engenharia Elétrica, Mecatrônica, Controle e Automação</li><li>Experiência no segmento automotivo em desenvolvimento de chicotes, roteamento e&nbsp;conexões elétricas</li><li>Conhecimento em processos de fabricação de chicotes</li><li>Habilidade de coordenação, capacitação e desenvolvimento do know-how&nbsp;de equipes</li><li>Experiência em softwares de design: CATIA,&nbsp;NX e/ou CAPITAL HARNESS</li><li>Conhecimento em ferramentas de desenvolvimento do produto: PLM (Enovia/Teamcenter)</li><li>Inglês nível avançado ou fluente</li></ul>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong></p>\n<ul><li>Pós-graduação em Gestão de Projetos</li><li>Mestrado em áreas relativas a sistemas eletroeletrônicos</li></ul>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, auxílio alimentação, auxílio combustível.</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1736416,"hash":"QY7W9Y85","position_name":"Referente Técnico - Sistemas Eletrônicos Automotivos","description":"<p>Empresa de engenharia do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<ul><li>Garantir a sinergia entre as soluções técnicas aplicadas nos subsistemas de eletrônicos embarcados, levando em conta a robustez, o atendimento de requisitos, materiais, objetivos de performance, custo, normas técnicas, planos de padronização, melhores práticas, lições aprendidas, dentre outras. </li><li>Gerir requisitos do produto&nbsp;e&nbsp;entregas técnicas da equipe&nbsp;</li><li>Garantir o design, prototipação, instalação, release e documentação técnica do produto </li><li>Capacitar o know-how e formação técnica&nbsp;da equipe</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Formação em Engenharia Elétrica, Mecatrônica, Controle e Automação</li><li>Conhecimento em arquitetura veicular, redes de comunicação veicular e&nbsp;requisitos de sistemas automotivos</li><li>Experiência em desenvolvimento de subsistemas embarcados automotivos:&nbsp;ADAS, conectividade, entretenimento&nbsp;e/ou&nbsp;BCM</li><li>Habilidade de coordenação de equipes e&nbsp;capacitação do know-how de especialistas</li><li>Conhecimento em ferramentas de desenvolvimento do produto: PLM. Desejável : ENOVIA/TEAMCENTER</li><li>Inglês nível avançado ou fluente</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n(completar)<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de Saúde, Plano odontológico, Auxílio Alimentação e auxílio transporte</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1726435,"hash":"L9VY4336","position_name":"Representante Comercial","description":"<p>A PTC Group em parceria com uma grande empresa de Energia Solar está buscando Representante Comercial para a cidade de Itabuna/BA.</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br><br></p>\n<ul><li>Planejamento do roteiro semana;</li><li>Negociação de pedidos, dentro do range de desconto;</li><li>Prospecção de novos clientes;</li><li>Participação em eventos;</li><li>Treinamento da equipe de vendas de clientes parceiros;</li><li>Follow up de negociações;</li><li>Elaboração de Plano de Ação para maiores clientes.</li></ul>\n<p><br></p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br><br></p>\n<ul><li>Ensino médio Completo;</li><li>Excel básico;</li><li>Empresa de Representação com Sócio;</li><li>Experiência na área comercial externa.</li></ul>\n<p></p>\n<p><br>\n\n</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"BA","city":"Itabuna","address":"","zipcode":"","location_display":"Itabuna, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1662971,"hash":"L9V8RXXY","position_name":"REPRESENTANTE COMERCIAL- RJ","description":"<p>A PTC Group em parceria com uma grande empresa de Energia Solar está buscando Representante Comercial para a cidade de Campos dos Goytacazes- RJ:</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br><br></p>\n<ul><li>Planejamento do roteiro semana;</li><li>Negociação de pedidos, dentro do range de desconto;</li><li>Prospecção de novos clientes;</li><li>Participação em eventos;</li><li>Treinamento da equipe de vendas de clientes parceiros;</li><li>Follow up de negociações;</li><li>Elaboração de Plano de Ação para maiores clientes.</li></ul>\n<p><br></p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br><br></p>\n<ul><li>Ensino médio Completo;</li><li>Excel básico;</li><li>Veículo próprio;</li><li>Empresa de Representação com Sócio;</li><li>Core atualizado;</li><li>Experiência na área comercial externa.</li></ul>\n<p></p>\n<p></p>","country":"Brazil","state":"RJ","city":"Campos","address":"","zipcode":"","location_display":"Campos, RJ, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1839221,"hash":"L76V8VV5","position_name":"Software Developer (Structural/Civil Engineering Background)","description":"<p>A PTC Group&nbsp;está a recrutar&nbsp;um Software Developer&nbsp;com formação académica e experiência em&nbsp;Engenharia Estrutural ou Civil&nbsp;para se juntar à nossa equipa num projeto cliente da área da Engenharia de Estruturas,&nbsp;na área do Grande Porto.</p>\n<p><strong>Descrição do Trabalho:</strong>&nbsp;</p>\n<p>O Software Developer&nbsp;será responsável por desenvolver soluções de software que aprimorem os processos de engenharia estrutural e digitais. Esta função&nbsp;requer conhecimentos profundos dos princípios de engenharia estrutural ou civil e a capacidade de traduzir esses princípios em aplicações e integrações&nbsp;de software.</p>\n<p><strong>Responsabilidades Principais:</strong></p>\n<ul><li>Desenvolver e manter aplicações de software a serem&nbsp;utilizadas em projetos de engenharia estrutural.</li><li>Colaborar com as equipas de engenharia para perceber os requisitos dos projetos e traduzi-los em especificações técnicas digitais.</li><li>Desenhar, escrever código, testar e fazer debug das&nbsp;aplicações de software para garantir que cumpram os padrões de engenharia e requisitos dos projetos.</li><li>Integrar novas soluções de software com ferramentas e fluxos de trabalho de engenharia existentes.</li><li>Fornecer suporte técnico e resolver problemas relacionados com o software nos projetos de engenharia.</li><li>Criar e manter documentação para as aplicações de software, incluindo manuais de utilizador e guias técnicos.</li><li>Colaborar com os diversos departamentos&nbsp;para desenvolver soluções de software adequadas.</li></ul>\n<p><strong>Qualificações:</strong></p>\n<ul><li>Licenciatura em Engenharia Civil ou Engenharia Estrutural.</li><li>Mínimo de 3 anos de experiência em Engenharia Civil ou Estrutural.</li><li>Experiência em desenvolvimento de software, preferencialmente com foco em aplicações para engenharia estrutural ou&nbsp;civil.</li><li>Proficiência em linguagens de programação como Python, Java, C++ ou similar.</li><li>Experiência com software de engenharia como AutoCAD, Tekla ou similar.</li><li>Forte compreensão dos princípios e práticas de engenharia estrutural ou civil.</li><li>Familiaridade com sistemas de gestão de bases de dados (por exemplo, SQL, PostgreSQL).</li><li>Conhecimento de tecnologias de desenvolvimento web (por exemplo, HTML, JavaScript, CSS).</li><li>Capacidade de trabalhar de forma independente e em equipa.</li><li>Excelentes habilidades de resolução de problemas e analíticas.</li><li>Fortes habilidades de comunicação e interpessoais.</li><li>Orientado para os detalhes com fortes habilidades organizacionais.</li></ul>","country":"Portugal","state":"Porto District","city":"Porto","address":"","zipcode":"","location_display":"Porto, Porto District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959677,"hash":"L3947548","position_name":"SQL Developer","description":"<p></p>\n<p>A PTC Group está a recrutar um SQL Developer para na zona do Porto ou Lisboa, em regime híbrido.</p>\n<p>Este Developer será responsável por:</p>\n<p></p>\n<p><strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Definir e redigir especificações técnicas para as soluções pretendidas e desenvolvidas.</li><li>Definir, publicar e assegurar a adesão às normas de desenvolvimento estabelecidas.</li><li>Criar e manter a eficiência dos recursos de Backend development.</li><li>Liderar iniciativas de R&D para soluções em tecnologia Oracle.</li><li>Aplicar práticas rigorosas de qualidade no desenvolvimento de código, com a inclusão de testes unitários promovam a automação contínua.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +4 anos de desenvolvimento de SQL.</li><li>Experiência com Oracle (preferencialmente Forms)</li><li>Experiência com Java e JavaScript.</li></ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1696451,"hash":"QX7WWVXR","position_name":"Structural Analysis Engineer (Stress Sector)","description":"<p><strong>Location:</strong> On-site in Evora, Portugal</p>\n<p><strong>Experience Level:</strong> Intermediate to Senior (Minimum 5 years of experience)</p>\n<p>We are hiring for our client company that develops and operates innovative products in mobility industries, specifically in Automotive and Urban Mobility, Aerospace, Ocean, and Space.</p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong><br></strong></span></p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong>Responsibilities:</strong></span></p><ul><li><span style=\"font-size: 1em; font-family: inherit;\"></span><span style=\"font-size: 1em;\">Conduct detailed structural analysis of aircraft primary structures, focusing on both metallic and composite materials.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Use CAE tools like Altair Hyperworks and NASTRAN for structural assessments.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Ensure safety and performance compliance through accurate sizing and dimensioning of structures.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Address fatigue issues and damage tolerance in components.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Collaborate with cross-functional teams for effective integration of structural analysis in the design process.</span></li></ul><p><strong><br></strong></p><p><strong><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Requirements:</span></strong></p><ul><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Bachelor's or Master's in Aerospace Engineering, Aeronautics, Mechanical Engineering, or related field.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Minimum 5 years of experience in aircraft structural analysis.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Proficiency in Altair Hyperworks and NASTRAN.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Extensive experience in sizing aircraft primary structures using metallic and composite materials.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Experience in mechanical systems calculation (e.g., door and/or landing systems).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Knowledge of fatigue analysis and damage tolerance in aerospace structures.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Fluency in Portuguese and English.</span></li></ul>","country":"Portugal","state":"Évora District","city":"Evora","address":"","zipcode":"","location_display":"Evora, Évora District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1715088,"hash":"QY7Y975V","position_name":"Supervisor Comercial de Aço Carbono","description":"<p><strong _msttexthash=\"1135381\" _msthash=\"3023\">Responsabilidades e Tarefas da Função</strong></p>\n<p _msttexthash=\"13614978\" _msthash=\"3022\">1 - Planejar e acompanhar execução dos planos de vendas, visando assegurar o cumprimento das metas estabelecidas, participação de mercado e lucratividade.</p>\n<p _msttexthash=\"22997039\" _msthash=\"3021\">2 - Organizar e supervisionar a distribuição das metas de vendas entre os vendedores e representantes da unidade da empresa, prestando apoio ao gerente para o cumprimento dos objetivos e metas estabelecidas.</p>\n<p _msttexthash=\"17112056\" _msthash=\"3020\">3 - Visitar clientes, acompanhando os vendedores externos e representantes de vendas, visando o fechamento de novos negócios e ampliação e consolidação do relacionamento.</p>\n<p _msttexthash=\"5484908\" _msthash=\"3019\">4 Identificar as necessidades dos clientes, visando à definição de formas de melhor atendê-lo.</p>\n<p _msttexthash=\"9311536\" _msthash=\"3018\">5 - Prestar esclarecimentos técnicos e ajudar os clientes na solução de problemas, visando ao atendimento de suas necessidades.</p>\n<p _msttexthash=\"8340930\" _msthash=\"3017\">6 Organizar material técnico de apoio, distribuir listas e promoções de venda, manter condições de venda atualizadas.</p>\n<p _msttexthash=\"4574999\" _msthash=\"3016\">7 - Elaborar e repassar os relatórios sob sua responsabilidade, nos prazos estipulados.</p>\n<p _msttexthash=\"2730832\" _msthash=\"3015\">9 Executar outras atividades de acordo com o seu superior imediato.</p>\n<p _msttexthash=\"2313818\" _msthash=\"3014\">10 Realizar entrevistas de novos colaboradores para o setor.</p>\n<p _msttexthash=\"3060564\" _msthash=\"3013\"><strong>Requisitos Obrigatórios</strong><br>Vir do segmento de indústria de aço carbono</p>\n<p _msttexthash=\"1647191\" _msthash=\"3012\"><strong>Requisitos Complementares</strong><br>3 anos de experiência</p>\n<p _msttexthash=\"2589795\" _msthash=\"3011\"><strong>O que oferecemos</strong><br>Fixo mais comissão e reembolso de combustível</p>","country":"Brazil","state":"RS","city":"Porto Alegre","address":"","zipcode":"","location_display":"Porto Alegre, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:58 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=15","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=13","results":[{"id":1963029,"hash":"L394Y5WV","position_name":"Project Manager","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar Project Managers para vários perfis (CyberSecurity, IT, Telco,&nbsp;Finance)&nbsp;para reforçar as nossas equipas, no Porto ou Lisboa.</span><br></p>\n<p>Estes Project Managers serão responsáveis por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer a gestão da informação e dos stakeholders dos projectos.</li><li>Supervisionar e planear tarefas a desenvolver por parte das equipas de projecto.</li><li>Identificar possíveis riscos para a execução dos projectos e desenvolver planos de mitigação dos mesmos.</li><li>Acompanhar todas as fases dos projectos, desde a sua concepção até ao fecho e&nbsp;entrega do mesmo.&nbsp;</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Gestão, Economia, TI, Redes ou similares.</li><li>Experiência mínima de +1 ano na área de Gestão de Projectos.</li><li>Experiência em projectos de em áreas como&nbsp;CyberSecurity, IT, Telco ou&nbsp;Finance.</li><li>Certificações ITIL, PMI, IPMA ou Prince2 (preferencial)</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1833768,"hash":"L64R6X8W","position_name":"Project Manager - Machining & Mechanical Assembly (Aerospace)","description":"<p>For our customer in FRANCE, a company specializing in the supply of parts and sub-assemblies dedicated to the <strong>aerospace </strong>industry, we are looking for a <strong>Project Manager for Machining &amp; Mechanical Assembly.</strong></p>\n<p><strong><br></strong></p>\n<p><strong>GENERAL INFORMATION:</strong></p>\n<ul><li>The candidate must be available to relocate to France (ROUEN) for a medium-term period (&gt;18 months).</li><li>The position may require geographical travel to clients and suppliers (Europe and Morroco).</li><li>The candidate can be from Portugal, France, or Spain.</li></ul>\n<p>The company specializes in:</p>\n<ul><li>Machining, sheet metal work, and assembly of complex metallic parts and sub-assemblies.</li><li>Machining of complex 5-axis parts (up to 12 meters), in aluminum and hard metals.</li><li>Aerospace sheet metal work / boiler-making qualified for Nadcap heat treatment.</li><li>Assembly of aircraft sub-assemblies (structural riveting).</li></ul>\n<p><strong><br></strong></p>\n<p><strong>JOB POSITION</strong></p>\n<ul><li>Participate in defining the project organization: human and material resources, budget, schedule, tasks and milestones, etc.</li><li>Participate in developing the project risk map.</li><li>Define project tracking indicators.</li><li>Ensure the execution of tasks by each project stakeholder under optimal conditions.</li><li>Ensure compliance with the budget allocated to each project line.</li><li>Ensure the delivery of deliverables at each project milestone.</li><li>Conduct project reviews with a specific focus on incurred costs and encountered difficulties.</li><li>Participate in the development of schedules for new projects (FAI/DVI).</li><li>Ensure adherence to these schedules until series production.</li><li>Ensure the start of programming in accordance with defined internal schedules.</li><li>Ensure that technical articles are properly created, MRP configuration is aligned with customer requirements, and FAI/DVI orders are launched properly.</li><li>Ensure timely material and component procurement.</li><li>Monitor the progression of production phases (machining, subcontracting, etc.).</li><li>Alert the Development Management in case of schedule deviations and propose recovery solutions aligned with various departments and customer requirements.</li><li>Support the Quality Management in scheduling necessary actions (FAI/DVI files, approval requests, waiver requests) during initial part production.</li><li>Ensure parts are shipped to the customer according to commitments made.</li><li>Conduct business reviews for new parts (collect and compile all phase cycle times, material purchase parts, surface treatment or component data) and report findings to the Development Management.</li><li>Propose actions to improve product costs and feasibility.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>RESPONSIBILITIES:</strong></p>\n<ul><li>Acts as the primary interface point with the client.</li><li>Acts as the internal \"multi-disciplinary\" interface point between Industry, Development Management, Logistics Management, and Quality Management for monitoring and/or initiating new markets.</li><li>Ensures compliance with the commercial policy.&nbsp;</li><li>Participates in progress review meetings with the client for all new developments and, when necessary, during series production.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>REQUIREMENTS:</strong></p>\n<ul><li>Bachelors degree +2 or Engineering degree.</li><li>3-5 years of working experience ﻿as a project manager or project technician in the same field.</li><li>English is mandatory; French is a plus.</li><li>Knowledge of machining (milling/turning), product process, and mechanical assembly - business relations (Sales).</li><li>Strong problem-solving skills, creativity, and willingness to think outside the box.</li><li>Ability to efficiently manage and communicate with cross-functional teams.</li><li>Exceptional verbal and written communication skills.</li><li>Good negotiation, conflict management, and problem-solving skills.</li><li>Ability to quickly adapt to the client.</li><li>Mandatory Workvisa or EU Citizenship﻿</li></ul>","country":"France","state":"Normandy","city":"Boos","address":"","zipcode":"","location_display":"Boos, Normandy, France","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1785724,"hash":"LR4VYR5R","position_name":"Projetista 2D - Suspensão","description":"<p>Profissional será responsável por projetos 2D de suspensão veicular</p>\n<p>REQUISITOS OBRIGATÓRIOS<br></p>\n<p>Inglês avançado</p>\n<p>Curso superior completo em engenharia mecânica ou áreas afins</p>\n<p>Necessário conhecimento em CATIA V5 e ou NX</p>\n<p>Necessário conhecimentos de GD&amp;T</p>\n<p>REQUISITOS DESEJÁVEIS</p>\n<p>Desejável conhecimento em PLM</p>\n<p>Desejável conhecimento em projetos de suspensão</p>\n<p>MODALIDADE:</p>\n<p>CLT<br>Hibrido em Betim - MG</p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1925703,"hash":"QX3VX4RY","position_name":"Projetista Mecânico","description":"<p>Junte-se a família PTC Group </p>\n<p>Estamos sempre a procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. </p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. </p>\n<p><strong>RESPONSABILIDADES E ATRIBUIÇÕES</strong></p>\n<p>Responsável pelo Desenvolvimento e modelamento dos projetos utilizando as ferramentas CATIA V5/V6 Unigraphics NX11, TeamCenter e Codep;</p>\n<p>Análise técnica de engenharia na concepção de novos produtos da engenharia automobilística.</p>\n<p><strong>REQUISITOS E QUALIFICAÇÕES</strong></p>\n<p>Curso superior em mecânica ou áreas correlatas ou curso técnico em ferramentaria, automação, mecânica;</p>\n<p>Cursos de injeção plástica, moldes, Autocad;</p>\n<p>Experiência em Catia V5 e NX;</p>\n<p>Desejável inglês avançado;</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Disponibilidade de atuação híbrido em Betim-MG.</span></p>","country":"","state":"","city":"","address":"","zipcode":"","location_display":"","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1958017,"hash":"L3948W3W","position_name":"Projetista Mulher","description":"<p>Junte-se a família PTC Group <br></p>\n<p>Estamos sempre à procura de talentos que tenham paixão pelo progresso, pela inovação e curiosidade para enfrentar os desafios que afetam a nossa sociedade de hoje. <br></p>\n<p>Somos uma multinacional de Engenharia &amp; TI, sendo parceiros confiáveis de grandes empresas mundiais. Focados no futuro, somos impulsionados pela procura da excelência em tudo que fazemos. <br></p>\n<p><strong>RESPONSABILIDADES E ATRIBUIÇÕES</strong></p>\n<p>Responsável pelo Desenvolvimento e modelamento dos projetos utilizando as ferramentas CATIA V5/V6 Unigraphics NX11, TeamCenter e Codep;</p>\n<p>Análise técnica de engenharia na concepção de novos produtos da engenharia automobilística.</p>\n<p><strong>REQUISITOS E QUALIFICAÇÕES</strong></p>\n<p>Curso superior em mecânica ou áreas correlatas ou curso técnico em ferramentaria, automação, mecânica;</p>\n<p>Cursos de injeção plástica, moldes, Autocad;</p>\n<p>Experiência em Catia V5 e NX;</p>\n<p>Desejável inglês avançado;</p>\n<p>Disponibilidade de atuação híbrido em Betim-MG;</p><p>Vaga exclusiva para mulheres.</p><p><br></p>\n<p></p>","country":"Brazil","state":"State of Minas Gerais","city":"Betim","address":"","zipcode":"","location_display":"Betim, State of Minas Gerais, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1753814,"hash":"QWYX9756","position_name":"Property Manager","description":"<p>Nos encontramos en la búsqueda de ﻿un Responsable de Edificios en el seno del equipo de Operaciones de una importante empresa&nbsp;gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p>\n<p>Este&nbsp;perfil será el responsable de explotación de un paquete de activos, debiendo ejecutar correctamente las&nbsp;siguientes tareas principales:</p>\n<ul><li>Elaborar y controlar el presupuesto de explotación de los activos.</li><li>Evaluar y atender propuestas de mejora de instalaciones procedentes del área de Facility Management.</li><li>Licitación y selección de subcontratistas necesarios para la correcta explotación de los edificios: seguridad, suministros, limpieza, conserjería, jardinería, mantenimiento, etc.</li><li>Contratar y renovar seguros de los edificios.</li><li>Representar ante terceros (juntas, reuniones de propietarios, administraciones públicas, etc.).</li><li>Garantizar el nivel de satisfacción de los inquilinos y desarrollar estrategias para minimizar la tasa de rotación en los alquileres.</li><li>Contribuir a la estrategia de comercialización de los activos.</li><li>Gestionar incidencias (privativas y zonas comunes).</li><li>Controlar y hacer seguimiento de la deuda.</li></ul>\n<p>El perfil reportará directamente al Director de Operaciones de la empresa y tendrá la oportunidad de contribuir en la definición de las líneas de desarrollo y crecimiento del departamento.<br></p>\n<p><strong>Requisitos:</strong><br></p>\n<ul><li>Haber completado estudios en Finanzas, Ingeniería, Economía, Administración y Dirección de Empresas, o campos afines. Se valorará positivamente cualquier formación complementaria relacionada con el puesto.</li><li>Experiencia mínima de 3 años en puestos de responsabilidad asociados a la gestión de activos inmobiliarios, preferiblemente en el ámbito residencial. Se valorará especialmente la experiencia en funciones realizadas directamente en los activos.</li><li>Dominio de herramientas de ofimática.</li><li>Nivel alto de inglés, tanto escrito como hablado.</li></ul>\n<p>Si cumples con los requisitos y estás interesado en formar parte de nuestro equipo, ¡esperamos tu solicitud!</p>\n<p>﻿﻿<br></p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959701,"hash":"QVXV76W8","position_name":"QA Automation Engineer/Tester (JavaScript e Inflecta)","description":"<p>A PTC Group está a recrutar um QA Automation Engineer/Tester para um projecto, na zona do Porto ou Lisboa, em regime híbrido.</p>\n<p>O Automation Engineer&nbsp;será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Criar e manter scripts de teste automatizados usando ferramentas apropriadas para garantir que o software funcione como esperado.</li><li>Executar testes automatizados para identificar defeitos e garantir que as funcionalidades do software estão a funcionar corretamente.</li><li>Rever os resultados dos testes automatizados, identificar falhas e reportar problemas à equipa de desenvolvimento.</li><li>Trabalhar em conjunto com os developers para resolver problemas identificados durante os testes e melhorar a qualidade do software.</li><li>Configurar e assegurar que o ambiente de teste está pronto para a execução dos testes automatizados.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +1 ano de desenvolvimento em JavaScript.</li><li>Experiência mínima de +1 ano com automatização de testes.</li><li>Experiência com ferramentas Inflecta (Spiratest, Rapise)</li></ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1963050,"hash":"QWYWRX59","position_name":"Quality Assurance Tester","description":"<p>A PTC Group está a recrutar um QA para reforçar a nossa equipa, no Porto.</p>\n<p>Este Quality Assurance&nbsp;serão responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer a análise e verificação de requisitos.</li><li>Escrever lista de testes a realizar e codificação dos mesmos.</li><li>Integração dos testes codificados para o ciclo de vida de desenvolvimento e de testes.</li><li>Criação de relatório com os resultados dos testes realizados e atuar sobre os mesmos</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, TI ou similar.</li><li>Experiência mínima de +1 ano como Quality Assurance Tester ou&nbsp;Engineer.</li><li>Experiência com integração de testes codificados e testes a requesitos não funcionais.</li><li>Certificações&nbsp;ISTQB,&nbsp;CSTE ou Azure (nice-to-have).</li></ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1962533,"hash":"L7696885","position_name":"Red Hat Enterprise Linux Engineer","description":"<p><strong>We are looking for a&nbsp;Red Hat Enterprise Linux Engineer to join PTC Group in one of our projects in Porto.</strong></p>\n<p><strong>The candidate to be chosen must be 100% on-premises during the first 2 or 3 months (time of successful onboarding). After, we have a working policy of 3 days in the office and 2 remote. Of course, the candidate can work 100% at our facilities after the onboarding process.</strong></p>\n<p><strong style=\"font-family: inherit; font-size: 0.875rem;\">Job Profile</strong><br></p>\n<ul>\n <li>Manage,      configure, upgrade and troubleshoot Linux servers in stand-alone or      clustered environments using automation.</li>\n <li>Manage,      configure, upgrade and troubleshoot Storage Servers and SAN Switches.</li>\n <li>Manage,      configure, upgrade and troubleshoot Vmware Servers.</li>\n <li>Interact      with other teams to fully understand and implement business requirements,      security policies, compliance rules and network connectivity flows.</li>\n</ul>\n<p><strong>Key Accountabilities</strong></p>\n<ul>\n <li>Ensure      that Linux servers have the appropriated availability, performance and      security that our business requires.</li>\n <li>Ensure      that every addition, removal or change done on the Linux servers is      properly managed through our automation platform.</li>\n <li>Ensure      that security policies and compliance rules are applied in the Linux      servers.</li>\n</ul>\n<p><strong>Knowledge, Skills and Experience Required</strong></p>\n<ul>\n <li>5+      years of experience in Linux systems administration.</li>\n <li>Experience      with Linux clustering.</li>\n <li>Experience      with automation.</li>\n <li>Experience      with Vmware.</li>\n <li>Experience      with Storage Servers.</li>\n <li>Demonstrated      knowledge of infrastructure services and networking topologies.</li>\n <li>Strong      organizational, multi-tasking, and time-management skills.</li>\n <li>Good      communication and interpersonal skills.</li>\n <li>Good      English communication skills (written and oral).</li>\n <li>Ability      to learn and apply new concepts quickly.</li>\n <li>Team      player.</li>\n</ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1962530,"hash":"L4Y5Y99V","position_name":"Red Hat OpenShift Engineer","description":"<p><strong>We are looking for a Red Hat OpenShift Engineer to join PTC Group in a project in Porto.&nbsp;<br></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\">The candidate to be chosen must be 100% on-premises during the first 2 or 3 months (time of successful onboarding). After, we have a working policy of 3 days in the office and 2 remote. Of course, the candidate can work 100% at our facilities after the onboarding process.</strong></p>\n<p><strong><br></strong></p>\n<p><strong>Job Profile</strong></p>\n<ul>\n <li>Manage,      configure, upgrade and troubleshoot Red Hat OpenShift infrastructure.</li>\n <li>Manage,      configure, upgrade and troubleshoot Storage Servers and SAN Switches.</li>\n <li>Interact      with other teams to fully understand and implement business requirements,      security policies, compliance rules and network connectivity flows.</li>\n</ul>\n<p><strong>Key Accountabilities</strong></p>\n<ul>\n <li>Ensure      that OpenShift infrastructure have the appropriated availability,      performance and security that our business requires.</li>\n <li>Ensure      that every addition, removal or change done on the OpenShift      infrastructure is properly managed through our automation platform.</li>\n <li>Ensure      that security policies and compliance rules are applied in the OpenShift      infrastructure.</li>\n</ul>\n<p><strong>Knowledge, Skills and Experience Required</strong></p>\n<ul>\n <li>5+      years of experience in OpenShift administration.</li>\n <li>System      administration, conceptualization, design, construction, and operation of      OpenShift platforms.</li>\n <li>Experience      with Red Hat Enterprise Linux (RHEL) and CI/CD tools.</li>\n <li>Experience      with automation.</li>\n <li>Experience      with Storage Servers.</li>\n <li>Demonstrated      knowledge of infrastructure services and networking topologies.</li>\n <li>Strong      organizational, multi-tasking, and time-management skills.</li>\n <li>Good      communication and interpersonal skills.</li>\n <li>Good      English communication skills (written and oral).</li>\n <li>Ability      to learn and apply new concepts quickly.</li>\n <li>Team      player.</li>\n</ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:44 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=15
@@ -856,11 +856,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:58 GMT
+      - Tue, 30 Jul 2024 16:28:45 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '25673'
+      - '19898'
       Connection:
       - keep-alive
       Server:
@@ -881,8 +881,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=16","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=14","results":[{"id":1658414,"hash":"QW9Y7RV6","position_name":"Supervisor de Vendas - Aço Carbono","description":"<p><font _mstmutation=\"1\" _msttexthash=\"2300025\" _msthash=\"2629\"></font></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"2793\">Responsabilidades e Tarefas da Função</strong></p>\n<p _msttexthash=\"13614978\" _msthash=\"2792\">1 - Planejar e acompanhar execução dos planos de vendas, visando assegurar o cumprimento das metas estabelecidas, participação de mercado e lucratividade.</p>\n<p _msttexthash=\"22997039\" _msthash=\"2791\">2 - Organizar e supervisionar a distribuição das metas de vendas entre os vendedores e representantes da unidade da empresa, prestando apoio ao gerente para o cumprimento dos objetivos e metas estabelecidas.</p>\n<p _msttexthash=\"17112056\" _msthash=\"2790\">3 - Visitar clientes, acompanhando os vendedores externos e representantes de vendas, visando o fechamento de novos negócios e ampliação e consolidação do relacionamento.</p>\n<p _msttexthash=\"5484908\" _msthash=\"2789\">4 Identificar as necessidades dos clientes, visando à definição de formas de melhor atendê-lo.</p>\n<p _msttexthash=\"9311536\" _msthash=\"2788\">5 - Prestar esclarecimentos técnicos e ajudar os clientes na solução de problemas, visando ao atendimento de suas necessidades.</p>\n<p _msttexthash=\"8340930\" _msthash=\"2787\">6 Organizar material técnico de apoio, distribuir listas e promoções de venda, manter condições de venda atualizadas.</p>\n<p _msttexthash=\"4574999\" _msthash=\"2786\">7 - Elaborar e repassar os relatórios sob sua responsabilidade, nos prazos estipulados.</p>\n<p _msttexthash=\"2730832\" _msthash=\"2785\">9 Executar outras atividades de acordo com o seu superior imediato.</p>\n<p _msttexthash=\"2313818\" _msthash=\"2784\">10 Realizar entrevistas de novos colaboradores para o setor.</p>\n<p _msttexthash=\"3060564\" _msthash=\"2783\"><strong>Requisitos Obrigatórios</strong><br>\nVir do segmento de indústria de aço carbono</p>\n<p _msttexthash=\"1647191\" _msthash=\"2782\"><strong>Requisitos Complementares</strong><br>\n3 anos de experiência</p>\n<p _msttexthash=\"2589795\" _msthash=\"2781\"><strong>O que oferecemos</strong><br>\nFixo mais comissão e reembolso de combustível</p>\n<p _msttexthash=\"615355\" _msthash=\"2625\"></p>\n<p><font _mstmutation=\"1\"></font><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716522,"hash":"L8RV497R","position_name":"Supervisor de Vendas - Aço Carbono","description":"<p><strong _msttexthash=\"1135381\" _msthash=\"2202\">Responsabilidades e Tarefas da Função</strong></p>\n<p _msttexthash=\"13614978\" _msthash=\"2201\">1 - Planejar e acompanhar execução dos planos de vendas, visando assegurar o cumprimento das metas estabelecidas, participação de mercado e lucratividade.</p>\n<p _msttexthash=\"22997039\" _msthash=\"2200\">2 - Organizar e supervisionar a distribuição das metas de vendas entre os vendedores e representantes da unidade da empresa, prestando apoio ao gerente para o cumprimento dos objetivos e metas estabelecidas.</p>\n<p _msttexthash=\"17112056\" _msthash=\"2199\">3 - Visitar clientes, acompanhando os vendedores externos e representantes de vendas, visando o fechamento de novos negócios e ampliação e consolidação do relacionamento.</p>\n<p _msttexthash=\"5484908\" _msthash=\"2198\">4 Identificar as necessidades dos clientes, visando à definição de formas de melhor atendê-lo.</p>\n<p _msttexthash=\"9311536\" _msthash=\"2197\">5 - Prestar esclarecimentos técnicos e ajudar os clientes na solução de problemas, visando ao atendimento de suas necessidades.</p>\n<p _msttexthash=\"8340930\" _msthash=\"2196\">6 Organizar material técnico de apoio, distribuir listas e promoções de venda, manter condições de venda atualizadas.</p>\n<p _msttexthash=\"4574999\" _msthash=\"2195\">7 - Elaborar e repassar os relatórios sob sua responsabilidade, nos prazos estipulados.</p>\n<p _msttexthash=\"2730832\" _msthash=\"2194\">9 Executar outras atividades de acordo com o seu superior imediato.</p>\n<p _msttexthash=\"2313818\" _msthash=\"2193\">10 Realizar entrevistas de novos colaboradores para o setor.</p>\n<p _msttexthash=\"3060564\" _msthash=\"2192\"><strong>Requisitos Obrigatórios</strong><br>Vir do segmento de indústria de aço carbono</p>\n<p _msttexthash=\"1647191\" _msthash=\"2191\"><strong>Requisitos Complementares</strong><br>3 anos de experiência</p>\n<p _msttexthash=\"2589795\" _msthash=\"2190\"><strong>O que oferecemos</strong><br>Fixo mais comissão e reembolso de combustível</p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1767278,"hash":"L4YRV9WV","position_name":"SysAdmin Linux e Microsoft","description":"<h4>Principais Atividades e Responsabilidades:</h4>\n<ul><li>Administração avançada de ambientes Linux e Microsoft.</li><li>Experiência sólida em Backup, Firewall e Power Shell.</li><li>Capacidade para suportar sistemas 24x7.</li><li>Conhecimentos em Storages IBM serão considerados um diferencial.</li></ul>\n<h4>O que buscamos?</h4>\n<ul><li>Experiência comprovada em administração de sistemas Linux e Microsoft.</li><li>Conhecimento avançado em Backup, Firewall e Power Shell.</li><li>Capacidade de suportar sistemas em regime 24x7.</li><li>Diferenciais: Experiência com Storages IBM.</li></ul>\n<h4>Detalhes da Vaga:</h4>\n<ul><li>Contratação: PJ (Pessoa Jurídica).</li><li>Local: Híbrido em Porto Alegre.</li></ul>","country":"Brazil","state":"RS","city":"Porto Alegre","address":"","zipcode":"","location_display":"Porto Alegre, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959790,"hash":"L4Y57RY5","position_name":"System Administrator (Solaris)","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um System Administrator para reforçar a nossa equipa, em regime híbrido.</span></p>\n<p>Este Administrator será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer o processo de gestão (suporte, análise, evolução e implementação) da infraestrutura Solaris.</li><li>Supervisionar o desempenho do sistema e realizar ajustes conforme necessário para garantir a eficiência e estabilidade do sistema.</li><li>Criar, modificar e eliminar contas de utilizador, configurar permissões e grupos de utilizadores, e garantir que as políticas de segurança sejam seguidas para proteger os dados e recursos do sistema.</li><li>Analisar e executar atividades de automação baseadas em Ansible e Scripting (Shell).</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +2 anos como System Administrator</li><li>Experiência mínima de +1 ano com sistemas Solaris</li><li>Conhecimentos em armazenamento e backups&nbsp;(EMC, SUN, Clarion)</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1751556,"hash":"L64W644W","position_name":"Team Leader Accounts Receivable","description":"<p><strong>Vaga: Team Leader Accounts Receivable</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p><br>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.<br>﻿<br>﻿<strong><br>﻿Responsabilidades:</strong></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p>\n<ul><li>Coordena o fluxo de trabalho para o departamento de acompanhamento/ faturação.&nbsp;</li><li>Atribui trabalho à equipa de Contas a Receber.&nbsp;</li><li>Acompanha as próprias contas/devedores em processo.&nbsp;</li><li>Assegura diretamente que todas as reclamações negadas ou rejeitadas são acompanhadas e tratadas de forma atempada.&nbsp;</li><li>Verifica aleatoriamente o trabalho para garantir precisão, eficiência e uniformidade.&nbsp;</li><li>Responde às questões da equipa de forma atempada, garantindo que compreendem completamente como desempenhar as suas funções.\nOrienta e treina a equipa.&nbsp;</li><li>Forma novos funcionários e funcionários existentes em técnicas.&nbsp;</li><li>Identifica proativamente tendências e inicia recomendações de mudança para o Gestor.&nbsp;</li><li>Fornece acompanhamento e gestão de fluxo de trabalho.&nbsp;</li><li>Exerce julgamento para tomar decisões sobre métodos e técnicas selecionadas para obter soluções.&nbsp;</li><li>Promove o trabalho em equipa, mantendo-se disponível para ajudar a equipa conforme necessário.&nbsp;</li><li>Lançamento de faturas de despesas gerais</li></ul>\n<p>﻿<strong>﻿<br>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura ou Mestrado em Contabilidade, Finanças, Administração e Gestão de Empresas, Ciências Empresariais, ou áreas semelhantes.</li><li>Experiência profissional: + de 5 anos&nbsp;na área. </li><li>Experiência em shared services.</li><li>Idiomas: Português nativo;&nbsp;Inglês fluente (comunicação regular com países estrangeiros).</li><li>Experiência em SAP S/4HANA e Excel.</li><li>Trabalho presencial em Aveiro</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1784736,"hash":"LR4V6566","position_name":"Técnico-Comercial (Moldes e Injeção)","description":"<p><strong>Posição: Técnico-Comercial (Moldes e Injeção)</strong></p>\n<p><strong>Localização: Leiria</strong></p>\n<p><br></p>\n<p><strong></strong>O nosso cliente fabrica moldes de aço para injeção de plásticos técnicos e de alto desempenho, destacando-se pela precisão e repetibilidade em todos os componentes, baseando-se em mais de 30 anos de conhecimento e oferecendo um serviço técnico personalizado.</p>\n<p><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li><strong></strong>Participar na definição da estratégia comercial em conformidade com o Plano Comercial Estratégico definido pela Gestão da Empresa;</li><li>Participar e Apoiar no Plano de Desenvolvimento de Negocio e Prospecção de mercado tendo como objetivo a diversificação de clientes, mercados e aumento das adjudicações;</li><li>Realizar a análise da viabilidade técnica, económica e de mercado dos projetos a desenvolver em consonância com os objetivos;</li><li>Assegurar a elaboração de planos de visita aos clientes, de acordo com a estratégia comercial definida;</li><li>Assegurar a elaboração de reporting comercial e relatórios;</li><li>Estabelecer e manter contacto com clientes habituais e potenciais, fomentando o relacionamento com acréscimo dos níveis de rentabilidade do negócio;</li><li>Participar ativamente nas reuniões internas de acompanhamento comercial;</li><li>Receber os pedidos de cotação e tratar a informação técnica e comercial garantindo o fluxo de informação para o departamento de orçamentação;</li><li>Preparação de propostas comerciais (moldes, alterações e pré-series) quer em termos técnicos como comerciais e financeiro;</li><li>Garantir o Follow Up das propostas em curso;</li><li>Negociar com os clientes, preços, prazos e soluções técnicas das possíveis adjudicações;</li><li>Assegurar a gestão da informação entre as áreas Técnica, Produção e Financeira;</li><li>Garantir reporte mensal dos indicadores de gestão comercial.</li></ul>\n<p><strong><strong><br></strong></strong></p>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li><strong></strong>Experiência na área dos moldes, de preferência em funções de contacto com cliente.</li><li>Formação académica superior (Engenharia), não sendo determinante para  a função;</li><li>Fluência na Língua inglesa (fator determinante) e Alemã/Espanhola/Francesa (não é exclusivo);</li><li>Forte orientação para os resultados;</li><li>Capacidade de liderança e resiliência;</li><li>Dinamismo e proatividade;</li><li>Competências de comunicação e negociação;</li><li>Disponibilidade para viagens.</li></ul>","country":"Portugal","state":"Leiria District","city":"Leiria","address":"","zipcode":"","location_display":"Leiria, Leiria District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1804073,"hash":"QVXYWWY8","position_name":"Técnico de Automação Industrial (PLC Siemens) - FRANÇA","description":"<p><strong>Posição:&nbsp;﻿Técnico de Automação Industrial (PLC Siemens)</strong></p>\n<p><strong>Localização: Rouen, Normandia, França</strong></p>\n<p><strong>Duração: &gt;3 meses</strong></p>\n<p><br></p>\n<p>A PTC Group está a recrutar para uma&nbsp;empresa é líder mundial em cabos e sistemas para energia e telecomunicações, oferecendo uma vasta gama de produtos, incluindo cabos subterrâneos e submarinos, sistemas de transmissão e soluções de conectividade para transmissão de voz, vídeo e dados.﻿</p>\n<p>﻿<strong><br></strong></p>\n<p><strong>﻿Responsabilidades:</strong><br></p>\n<ul><li> Programar e configurar PLCs Siemens para o controlo e automação de processos industriais.</li><li> Realizar a manutenção preventiva e corretiva de sistemas automatizados.</li><li> Diagnosticar e resolver problemas técnicos relacionados com automação.</li><li> Colaborar com outros departamentos para melhorar a eficiência e qualidade dos processos.</li><li> Documentar procedimentos e atualizações de sistemas.</li><li> Assegurar o cumprimento das normativas de segurança e qualidade.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos:</strong></p>\n<ul><li> Diploma técnico ou universitário em Automação, Eletrónica, Mecatrónica ou área relacionada.</li><li> Mínimo de 3 anos de experiência em programação e manutenção de sistemas de automação Siemens.</li><li> Conhecimento profundo de PLC Siemens (S7-1200, S7-1500), HMI e sistemas SCADA.</li><li> Experiência em integração de sistemas e comunicação industrial (Profibus, Profinet, etc.).</li><li> Capacidade para interpretar esquemas elétricos e planos de automação.</li><li> Capacidade de trabalhar de forma independente e em equipa.</li><li> Excelentes capacidades de resolução de problemas e atenção aos detalhes.</li><li> Disponibilidade para trabalhar em horários flexíveis e realizar deslocações ocasionais conforme as necessidades do projeto.</li><li>Ter cidadania europeia.</li><li> Idiomas: Inglês (Fluente) OU Francês (Fluente)</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Informação adicional:</strong></p>\n<ul><li>﻿﻿Duração: pelo menos&nbsp;3 meses<br></li><li>Salário competitivo baseado na experiência do candidato.</li><li> Compensação por deslocalização na França.</li><li> Contratação imediata.</li></ul>","country":"France","state":"Normandy","city":"Rouen","address":"","zipcode":"","location_display":"Rouen, Normandy, France","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1833543,"hash":"L5398V5R","position_name":"Técnico de Automatismos﻿ Júnior","description":"<p><strong>Posição:&nbsp;﻿Técnico de Automatismos﻿ Júnior</strong></p>\n<p><strong>Localização: Portugal</strong></p>\n<p></p>\n<p>Estamos a procurar um Técnico de Automatismos Júnior para o nosso cliente localizado em Vigo, que desenvolve soluções seguras, eficientes, inteligentes e potentes para a automação de fábricas, aplicações móveis, aplicações de maquinaria e engenharia. </p>\n<p>Esta é uma grande oportunidade numa grande empresa multinacional, com um bom ambiente de trabalho e oportunidade para desenvolvimento profissional.</p>\n<p><strong>Procuramos uma pessoa que esteja localizada em Portugal Continental, com disponibilidade para realizar a formação inicial de 3 a 6 meses em Vigo, sendo o trabalho efetuado posteriormente em regime híbrido (em Portugal, nos clientes do nosso cliente).</strong></p>\n<p><strong><br></strong></p>\n<p><strong>Tarefas e responsabilidades:</strong></p>\n<ul><li>Criação e redação dos padrões de compra a nível de Automatismos, Robótica e Mecânica.</li><li>Pilotagem de Projetos de Automatismos, Robótica e Mecânica na área de montagem (Fase de Preparação, Fase de Estudos, Fase de Montagem, Fase de Arranque e Aumento de Cadência).</li><li>Coordenação, gestão, controlo de trabalhos das subcontratas a nível de qualidade, prazos e segurança.</li><li>Análise técnica de todos os programas de autómatos e periféricos e da documentação.</li><li>Verificação do cumprimento de padrões, funcionalidades e desempenho operacional exigido.</li><li>Realização de esquemas elétricos e/ou pneumáticos.</li><li>Acompanhamento de montagens elétricas e/ou pneumáticas.</li><li>Programação de autómatos (Siemens, Schneider, Rockwell...) e telas IHM.</li><li>Arranque de maquinaria e/ou instalações.</li><li>Reporte das incidências pertinentes aos responsáveis.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos:</strong></p>\n<ul><li>Estudos mínimos: Curso Técnico de Nível Superior em Automação e Robótica Industrial ou Eletricidade.</li><li>Valorizamos experiência em programação de autómatos, elaboração de esquemas eléctricos,&nbsp;programação robótica.﻿</li><li>Valorizamos conhecimentos do idioma inglês.</li><li>Valorizamos a atitude do candidato em aprender e melhorar acima da sua experiência ou conhecimentos prévios.</li></ul>","country":"Portugal","state":"Aveiro District","city":"Oliveira de Azeméis","address":"","zipcode":"","location_display":"Oliveira de Azeméis, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938321,"hash":"L7635873","position_name":"Técnico de Instalação Júnior (Sistemas de Visão Computacional)","description":"<p><strong>Posição: Técnico de Instalação Júnior (Sistemas de Visão Computacional)</strong></p>\n<p><strong>Localização: Guimarães (100% presencial)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma&nbsp;empresa especialista em visão artificial,&nbsp;integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a&nbsp;<strong>automatização de processos</strong>.</p>\n<p><br></p>\n<p><strong><strong>Responsabilidades</strong></strong></p>\n<ul>\n <li>Levantamento de requisitos do cliente</li>\n <li>Instalação, configuração e parametrização de equipamentos de visão      artificial (computadores, câmaras industriais, lentes, leds)</li>\n <li>Manutenção de sistemas em ambiente de produção</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos</strong></p>\n<ul>\n <li>Curso técnico ou geral relacionado com as áreas de      eletrónica ou automação.</li>\n <li>Experiência +1 anos na implementação de soluções automatizadas e contacto com processos produtivos na indústria.﻿</li><li>Conhecimentos básicos de matemática, lógica,      linguagens de programação. </li>\n <li>Conhecimentos básicos de eletrónica e informática. </li>\n <li>Conhecimentos em visão computacional é um extra.</li>\n <li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1784680,"hash":"L64XWY4R","position_name":"Técnico de Metrologia Tridimensional (Fins de Semana)","description":"<p><strong>Posição:&nbsp;﻿Técnico de Metrologia Tridimensional (Fins de Semana)</strong></p>\n<p><strong>﻿Localização: Vila Nova de Cerveira, Viana do Castelo<br></strong></p>\n<p><strong>﻿Regime de trabalho:&nbsp;﻿turnos de 12h/dia (sábados e domingos),&nbsp;﻿com início às 06h ou 09h da manhã - até final deste ano<br></strong></p>\n<p><strong>﻿</strong><br></p>\n<p>O nosso cliente é uma empresa global de tecnologia que fornece produtos e sistemas de mobilidade avançada para automóveis de passageiros, veículos comerciais e tecnologia industrial. A sua vasta gama de produtos destina-se principalmente a fabricantes de veículos, fornecedores de mobilidade e startups nas áreas de transporte e mobilidade.</p>\n<p><br></p>\n<p><strong></strong><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li><strong><strong>﻿</strong></strong>Calibrar e manter os instrumentos de medição e os equipamentos de teste, assegurando que se ajustam às normas e especificações estabelecidas.</li><li>Realizar verificações periódicas e preventivas para garantir a precisão e fiabilidade dos instrumentos de medição.</li><li>Medir componentes e produtos utilizando diversos equipamentos de medição, como micrómetros, calibres, comparadores ópticos, máquinas de medição por coordenadas (MMC), entre outros.</li><li>Inspecionar peças e produtos durante e após a fabricação para garantir que se ajustam às tolerâncias e especificações técnicas.</li><li>Analisar os dados de medição e gerar relatórios detalhados sobre a conformidade dos produtos.</li><li>Identificar desvios e não conformidades, sugerindo ações corretivas para resolver problemas de qualidade.</li><li>Colaborar com os engenheiros de produção e outros departamentos para resolver problemas de qualidade e melhorar os processos de fabricação.</li><li>Proporcionar apoio técnico e formação aos operadores de máquinas sobre o uso adequado dos equipamentos de medição.</li><li>Participar no desenvolvimento e implementação de novos processos de medição e controlo de qualidade.</li><li>Propor melhorias nos métodos e procedimentos de medição para aumentar a eficácia e a precisão.</li><li>Manter registos detalhados das calibrações, inspeções e manutenção dos equipamentos.</li><li>Garantir que todas as atividades de medição e calibração cumprem as normas internas e a regulamentação externa aplicável (ISO, ASME, etc.).</li><li>Participar em projetos de desenvolvimento de novos produtos e processos, proporcionando apoio metrológico desde a fase de conceção até à produção em série.</li><li>Realizar estudos de repetibilidade e reprodutibilidade (R&amp;R) para avaliar a precisão dos processos de medição</li></ul>\n<p><br></p>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li><strong><strong></strong></strong>Elevado conhecimento na utilização da máquina de medição por coordenadas com software <strong>Metrolog. CMM - fator eliminatório</strong></li><li><strong></strong>Conhecimentos profundos de metrologia e princípios de medição.</li><li>Familiaridade com instrumentos de medição avançados e equipamentos de calibração.</li><li>Conhecimento das normas e regulamentos aplicáveis à metrologia e controlo de qualidade.</li><li>Capacidade para interpretar desenhos e especificações técnicas.</li><li>Competência para analisar dados de medição e gerar relatórios precisos.</li><li>Elevado nível de precisão e cuidado nos processos de medição e inspeção.</li><li>Capacidade para identificar e corrigir erros menores que possam afetar a qualidade do produto.</li><li>Formação técnica em metrologia, engenharia de produção, engenharia mecânica ou áreas relacionadas.</li><li>Experiência prévia num ambiente de fabricação, preferencialmente no setor automóvel.</li><li>Trabalho em laboratórios de metrologia e ambientes de produção.</li><li>Utilização de software especializado para a análise de dados e controlo de qualidade.</li><li>Cumprimento de rigorosas normas de segurança e qualidade, garantindo a proteção tanto do técnico como da integridade dos produtos</li><li>Fluência no idioma Português; inglês valorizado.</li></ul>","country":"Portugal","state":"Viana do Castelo District","city":"Vila Nova de Cerveira","address":"","zipcode":"","location_display":"Vila Nova de Cerveira, Viana do Castelo District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"part_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:58 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=16","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=14","results":[{"id":1688145,"hash":"L773VR43","position_name":"Referente Técnico - Sistemas Eletroeletrônicos (Chicotes e Distribuição)","description":"<p>Indústria do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong>﻿</strong></p>\n<ul><li><strong></strong>Garantir a sinergia entre as soluções técnicas aplicadas nos subsistemas de eletrônicos embarcados, levando&nbsp;em conta a robustez, o atendimento de requisitos, materiais, objetivos de performance, custo, normas técnicas, planos de padronização, melhores práticas, lições aprendidas, dentre outras.&nbsp;</li><li>Responsável pela divulgação e cumprimento da especificação dos componentes durante o desenvolvimento de novos produtos e de série.</li><li>Garantir o design, prototipação, instalação,&nbsp;release e documentação técnica do produto&nbsp;</li><li>Desenvolvimento de fornecedores﻿﻿</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong>﻿</strong></p>\n<ul><li>Formação em Engenharia Elétrica, Mecatrônica, Controle e Automação</li><li>Experiência no segmento automotivo em desenvolvimento de chicotes, roteamento e&nbsp;conexões elétricas</li><li>Conhecimento em processos de fabricação de chicotes</li><li>Habilidade de coordenação, capacitação e desenvolvimento do know-how&nbsp;de equipes</li><li>Experiência em softwares de design: CATIA,&nbsp;NX e/ou CAPITAL HARNESS</li><li>Conhecimento em ferramentas de desenvolvimento do produto: PLM (Enovia/Teamcenter)</li><li>Inglês nível avançado ou fluente</li></ul>\n<p><strong><strong>Requisitos Complementares</strong>﻿</strong></p>\n<ul><li>Pós-graduação em Gestão de Projetos</li><li>Mestrado em áreas relativas a sistemas eletroeletrônicos</li></ul>\n<p><strong><strong>O que oferecemos</strong>﻿</strong><br>Plano de saúde, auxílio alimentação, auxílio combustível.</p>\n<p>﻿<br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1736416,"hash":"QY7W9Y85","position_name":"Referente Técnico - Sistemas Eletrônicos Automotivos","description":"<p>Empresa de engenharia do setor automotivo.<br><br></p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br></p>\n<ul><li>Garantir a sinergia entre as soluções técnicas aplicadas nos subsistemas de eletrônicos embarcados, levando em conta a robustez, o atendimento de requisitos, materiais, objetivos de performance, custo, normas técnicas, planos de padronização, melhores práticas, lições aprendidas, dentre outras. </li><li>Gerir requisitos do produto&nbsp;e&nbsp;entregas técnicas da equipe&nbsp;</li><li>Garantir o design, prototipação, instalação, release e documentação técnica do produto </li><li>Capacitar o know-how e formação técnica&nbsp;da equipe</li></ul>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<ul><li>Formação em Engenharia Elétrica, Mecatrônica, Controle e Automação</li><li>Conhecimento em arquitetura veicular, redes de comunicação veicular e&nbsp;requisitos de sistemas automotivos</li><li>Experiência em desenvolvimento de subsistemas embarcados automotivos:&nbsp;ADAS, conectividade, entretenimento&nbsp;e/ou&nbsp;BCM</li><li>Habilidade de coordenação de equipes e&nbsp;capacitação do know-how de especialistas</li><li>Conhecimento em ferramentas de desenvolvimento do produto: PLM. Desejável : ENOVIA/TEAMCENTER</li><li>Inglês nível avançado ou fluente</li></ul>\n<p><strong><strong>Requisitos Complementares</strong></strong><br>\n(completar)<strong><strong></strong></strong></p>\n<p><strong><strong>O que oferecemos</strong></strong><br>Plano de Saúde, Plano odontológico, Auxílio Alimentação e auxílio transporte</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"MG","city":"Betim","address":"","zipcode":"","location_display":"Betim, MG, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":true},{"id":1726435,"hash":"L9VY4336","position_name":"Representante Comercial","description":"<p>A PTC Group em parceria com uma grande empresa de Energia Solar está buscando Representante Comercial para a cidade de Itabuna/BA.</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br><br></p>\n<ul><li>Planejamento do roteiro semana;</li><li>Negociação de pedidos, dentro do range de desconto;</li><li>Prospecção de novos clientes;</li><li>Participação em eventos;</li><li>Treinamento da equipe de vendas de clientes parceiros;</li><li>Follow up de negociações;</li><li>Elaboração de Plano de Ação para maiores clientes.</li></ul>\n<p><br></p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br><br></p>\n<ul><li>Ensino médio Completo;</li><li>Excel básico;</li><li>Empresa de Representação com Sócio;</li><li>Experiência na área comercial externa.</li></ul>\n<p></p>\n<p><br>\n\n</p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"BA","city":"Itabuna","address":"","zipcode":"","location_display":"Itabuna, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1662971,"hash":"L9V8RXXY","position_name":"REPRESENTANTE COMERCIAL- RJ","description":"<p>A PTC Group em parceria com uma grande empresa de Energia Solar está buscando Representante Comercial para a cidade de Campos dos Goytacazes- RJ:</p>\n<p><strong><strong>Responsabilidades e Tarefas da Função</strong></strong><br><br></p>\n<ul><li>Planejamento do roteiro semana;</li><li>Negociação de pedidos, dentro do range de desconto;</li><li>Prospecção de novos clientes;</li><li>Participação em eventos;</li><li>Treinamento da equipe de vendas de clientes parceiros;</li><li>Follow up de negociações;</li><li>Elaboração de Plano de Ação para maiores clientes.</li></ul>\n<p><br></p>\n<p></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br><br></p>\n<ul><li>Ensino médio Completo;</li><li>Excel básico;</li><li>Veículo próprio;</li><li>Empresa de Representação com Sócio;</li><li>Core atualizado;</li><li>Experiência na área comercial externa.</li></ul>\n<p></p>\n<p></p>","country":"Brazil","state":"RJ","city":"Campos","address":"","zipcode":"","location_display":"Campos, RJ, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1959677,"hash":"L3947548","position_name":"SQL Developer","description":"<p></p>\n<p>A PTC Group está a recrutar um SQL Developer para na zona do Porto ou Lisboa, em regime híbrido.</p>\n<p>Este Developer será responsável por:</p>\n<p></p>\n<p><strong></strong><strong style=\"font-family: inherit; font-size: 0.875rem;\"><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Definir e redigir especificações técnicas para as soluções pretendidas e desenvolvidas.</li><li>Definir, publicar e assegurar a adesão às normas de desenvolvimento estabelecidas.</li><li>Criar e manter a eficiência dos recursos de Backend development.</li><li>Liderar iniciativas de R&D para soluções em tecnologia Oracle.</li><li>Aplicar práticas rigorosas de qualidade no desenvolvimento de código, com a inclusão de testes unitários promovam a automação contínua.</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +4 anos de desenvolvimento de SQL.</li><li>Experiência com Oracle (preferencialmente Forms)</li><li>Experiência com Java e JavaScript.</li></ul>","country":"Portugal","state":"","city":"Porto","address":"","zipcode":"","location_display":"Porto, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1696451,"hash":"QX7WWVXR","position_name":"Structural Analysis Engineer (Stress Sector)","description":"<p><strong>Location:</strong> On-site in Evora, Portugal</p>\n<p><strong>Experience Level:</strong> Intermediate to Senior (Minimum 5 years of experience)</p>\n<p>We are hiring for our client company that develops and operates innovative products in mobility industries, specifically in Automotive and Urban Mobility, Aerospace, Ocean, and Space.</p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong><br></strong></span></p><p><span style=\"font-size: 1em; font-family: inherit;\"><strong>Responsibilities:</strong></span></p><ul><li><span style=\"font-size: 1em; font-family: inherit;\"></span><span style=\"font-size: 1em;\">Conduct detailed structural analysis of aircraft primary structures, focusing on both metallic and composite materials.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Use CAE tools like Altair Hyperworks and NASTRAN for structural assessments.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Ensure safety and performance compliance through accurate sizing and dimensioning of structures.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Address fatigue issues and damage tolerance in components.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Collaborate with cross-functional teams for effective integration of structural analysis in the design process.</span></li></ul><p><strong><br></strong></p><p><strong><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Requirements:</span></strong></p><ul><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Bachelor's or Master's in Aerospace Engineering, Aeronautics, Mechanical Engineering, or related field.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Minimum 5 years of experience in aircraft structural analysis.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Proficiency in Altair Hyperworks and NASTRAN.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Extensive experience in sizing aircraft primary structures using metallic and composite materials.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Experience in mechanical systems calculation (e.g., door and/or landing systems).</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Knowledge of fatigue analysis and damage tolerance in aerospace structures.</span></li><li><span style=\"font-size: 1em;\"></span><span style=\"font-size: 1em;\">Fluency in Portuguese and English.</span></li></ul>","country":"Portugal","state":"Évora District","city":"Evora","address":"","zipcode":"","location_display":"Evora, Évora District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1715088,"hash":"QY7Y975V","position_name":"Supervisor Comercial de Aço Carbono","description":"<p><strong _msttexthash=\"1135381\" _msthash=\"3023\">Responsabilidades e Tarefas da Função</strong></p>\n<p _msttexthash=\"13614978\" _msthash=\"3022\">1 - Planejar e acompanhar execução dos planos de vendas, visando assegurar o cumprimento das metas estabelecidas, participação de mercado e lucratividade.</p>\n<p _msttexthash=\"22997039\" _msthash=\"3021\">2 - Organizar e supervisionar a distribuição das metas de vendas entre os vendedores e representantes da unidade da empresa, prestando apoio ao gerente para o cumprimento dos objetivos e metas estabelecidas.</p>\n<p _msttexthash=\"17112056\" _msthash=\"3020\">3 - Visitar clientes, acompanhando os vendedores externos e representantes de vendas, visando o fechamento de novos negócios e ampliação e consolidação do relacionamento.</p>\n<p _msttexthash=\"5484908\" _msthash=\"3019\">4 Identificar as necessidades dos clientes, visando à definição de formas de melhor atendê-lo.</p>\n<p _msttexthash=\"9311536\" _msthash=\"3018\">5 - Prestar esclarecimentos técnicos e ajudar os clientes na solução de problemas, visando ao atendimento de suas necessidades.</p>\n<p _msttexthash=\"8340930\" _msthash=\"3017\">6 Organizar material técnico de apoio, distribuir listas e promoções de venda, manter condições de venda atualizadas.</p>\n<p _msttexthash=\"4574999\" _msthash=\"3016\">7 - Elaborar e repassar os relatórios sob sua responsabilidade, nos prazos estipulados.</p>\n<p _msttexthash=\"2730832\" _msthash=\"3015\">9 Executar outras atividades de acordo com o seu superior imediato.</p>\n<p _msttexthash=\"2313818\" _msthash=\"3014\">10 Realizar entrevistas de novos colaboradores para o setor.</p>\n<p _msttexthash=\"3060564\" _msthash=\"3013\"><strong>Requisitos Obrigatórios</strong><br>Vir do segmento de indústria de aço carbono</p>\n<p _msttexthash=\"1647191\" _msthash=\"3012\"><strong>Requisitos Complementares</strong><br>3 anos de experiência</p>\n<p _msttexthash=\"2589795\" _msthash=\"3011\"><strong>O que oferecemos</strong><br>Fixo mais comissão e reembolso de combustível</p>","country":"Brazil","state":"RS","city":"Porto Alegre","address":"","zipcode":"","location_display":"Porto Alegre, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1658414,"hash":"QW9Y7RV6","position_name":"Supervisor de Vendas - Aço Carbono","description":"<p><font _mstmutation=\"1\" _msttexthash=\"2300025\" _msthash=\"2629\"></font></p>\n<p><strong _msttexthash=\"1135381\" _msthash=\"2793\">Responsabilidades e Tarefas da Função</strong></p>\n<p _msttexthash=\"13614978\" _msthash=\"2792\">1 - Planejar e acompanhar execução dos planos de vendas, visando assegurar o cumprimento das metas estabelecidas, participação de mercado e lucratividade.</p>\n<p _msttexthash=\"22997039\" _msthash=\"2791\">2 - Organizar e supervisionar a distribuição das metas de vendas entre os vendedores e representantes da unidade da empresa, prestando apoio ao gerente para o cumprimento dos objetivos e metas estabelecidas.</p>\n<p _msttexthash=\"17112056\" _msthash=\"2790\">3 - Visitar clientes, acompanhando os vendedores externos e representantes de vendas, visando o fechamento de novos negócios e ampliação e consolidação do relacionamento.</p>\n<p _msttexthash=\"5484908\" _msthash=\"2789\">4 Identificar as necessidades dos clientes, visando à definição de formas de melhor atendê-lo.</p>\n<p _msttexthash=\"9311536\" _msthash=\"2788\">5 - Prestar esclarecimentos técnicos e ajudar os clientes na solução de problemas, visando ao atendimento de suas necessidades.</p>\n<p _msttexthash=\"8340930\" _msthash=\"2787\">6 Organizar material técnico de apoio, distribuir listas e promoções de venda, manter condições de venda atualizadas.</p>\n<p _msttexthash=\"4574999\" _msthash=\"2786\">7 - Elaborar e repassar os relatórios sob sua responsabilidade, nos prazos estipulados.</p>\n<p _msttexthash=\"2730832\" _msthash=\"2785\">9 Executar outras atividades de acordo com o seu superior imediato.</p>\n<p _msttexthash=\"2313818\" _msthash=\"2784\">10 Realizar entrevistas de novos colaboradores para o setor.</p>\n<p _msttexthash=\"3060564\" _msthash=\"2783\"><strong>Requisitos Obrigatórios</strong><br>\nVir do segmento de indústria de aço carbono</p>\n<p _msttexthash=\"1647191\" _msthash=\"2782\"><strong>Requisitos Complementares</strong><br>\n3 anos de experiência</p>\n<p _msttexthash=\"2589795\" _msthash=\"2781\"><strong>O que oferecemos</strong><br>\nFixo mais comissão e reembolso de combustível</p>\n<p _msttexthash=\"615355\" _msthash=\"2625\"></p>\n<p><font _mstmutation=\"1\"></font><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1716522,"hash":"L8RV497R","position_name":"Supervisor de Vendas - Aço Carbono","description":"<p><strong _msttexthash=\"1135381\" _msthash=\"2202\">Responsabilidades e Tarefas da Função</strong></p>\n<p _msttexthash=\"13614978\" _msthash=\"2201\">1 - Planejar e acompanhar execução dos planos de vendas, visando assegurar o cumprimento das metas estabelecidas, participação de mercado e lucratividade.</p>\n<p _msttexthash=\"22997039\" _msthash=\"2200\">2 - Organizar e supervisionar a distribuição das metas de vendas entre os vendedores e representantes da unidade da empresa, prestando apoio ao gerente para o cumprimento dos objetivos e metas estabelecidas.</p>\n<p _msttexthash=\"17112056\" _msthash=\"2199\">3 - Visitar clientes, acompanhando os vendedores externos e representantes de vendas, visando o fechamento de novos negócios e ampliação e consolidação do relacionamento.</p>\n<p _msttexthash=\"5484908\" _msthash=\"2198\">4 Identificar as necessidades dos clientes, visando à definição de formas de melhor atendê-lo.</p>\n<p _msttexthash=\"9311536\" _msthash=\"2197\">5 - Prestar esclarecimentos técnicos e ajudar os clientes na solução de problemas, visando ao atendimento de suas necessidades.</p>\n<p _msttexthash=\"8340930\" _msthash=\"2196\">6 Organizar material técnico de apoio, distribuir listas e promoções de venda, manter condições de venda atualizadas.</p>\n<p _msttexthash=\"4574999\" _msthash=\"2195\">7 - Elaborar e repassar os relatórios sob sua responsabilidade, nos prazos estipulados.</p>\n<p _msttexthash=\"2730832\" _msthash=\"2194\">9 Executar outras atividades de acordo com o seu superior imediato.</p>\n<p _msttexthash=\"2313818\" _msthash=\"2193\">10 Realizar entrevistas de novos colaboradores para o setor.</p>\n<p _msttexthash=\"3060564\" _msthash=\"2192\"><strong>Requisitos Obrigatórios</strong><br>Vir do segmento de indústria de aço carbono</p>\n<p _msttexthash=\"1647191\" _msthash=\"2191\"><strong>Requisitos Complementares</strong><br>3 anos de experiência</p>\n<p _msttexthash=\"2589795\" _msthash=\"2190\"><strong>O que oferecemos</strong><br>Fixo mais comissão e reembolso de combustível</p>","country":"Brazil","state":"SP","city":"São Paulo","address":"","zipcode":"","location_display":"São Paulo, SP, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1767278,"hash":"L4YRV9WV","position_name":"SysAdmin Linux e Microsoft","description":"<h4>Principais Atividades e Responsabilidades:</h4>\n<ul><li>Administração avançada de ambientes Linux e Microsoft.</li><li>Experiência sólida em Backup, Firewall e Power Shell.</li><li>Capacidade para suportar sistemas 24x7.</li><li>Conhecimentos em Storages IBM serão considerados um diferencial.</li></ul>\n<h4>O que buscamos?</h4>\n<ul><li>Experiência comprovada em administração de sistemas Linux e Microsoft.</li><li>Conhecimento avançado em Backup, Firewall e Power Shell.</li><li>Capacidade de suportar sistemas em regime 24x7.</li><li>Diferenciais: Experiência com Storages IBM.</li></ul>\n<h4>Detalhes da Vaga:</h4>\n<ul><li>Contratação: PJ (Pessoa Jurídica).</li><li>Local: Híbrido em Porto Alegre.</li></ul>","country":"Brazil","state":"RS","city":"Porto Alegre","address":"","zipcode":"","location_display":"Porto Alegre, RS, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:45 GMT
 - request:
     method: get
     uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=16
@@ -902,11 +902,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:59 GMT
+      - Tue, 30 Jul 2024 16:28:45 GMT
       Content-Type:
       - application/json
       Content-Length:
-      - '19145'
+      - '24705'
       Connection:
       - keep-alive
       Server:
@@ -927,8 +927,54 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"count":158,"next":null,"previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=15","results":[{"id":1658255,"hash":"L5735335","position_name":"Técnico de Segurança do Trabalho","description":"<p>A PTC Group está em busca de&nbsp;um&nbsp;Técnico em Segurança do Trabalho&nbsp;para Maceió-AL<br><br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p><br></p>\n<ul><li>Técnico em Segurança do Trabalho com Registro no MTE;</li><li>Conhecimento em Normas Regulamentadoras;</li><li>Conhecimento em pacote office.</li></ul>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"AL","city":"Maceió","address":"","zipcode":"","location_display":"Maceió, AL, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1755156,"hash":"L64W454W","position_name":"Técnico Eletrônico","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Técnico Eletrônico: com experiência mínima, comprovada em carteira, de 4 anos, curso</span></p>\n<p>referente a NR-10. O mesmo deve possuir conhecimentos em reparos de placas de</p>\n<p>circuito eletrônico de inversores, fontes de alimentação e outros equipamentos, digitais e analógicas, com a utilização de osciloscópio, multímetro, estação de retrabalho e afins; Com experiência mínima, comprovada em carteira, de 4 anos em manutenção em bancada de equipamentos de máquinas industriais;</p>\n<p>﻿<br></p>\n<p>﻿Escopo de atividades:<br></p>\n<p>﻿﻿Faz parte do escopo de serviço as seguintes atividades:<br>A. Realização de serviços gerais de manutenção elétrica e eletrônica, como:<br>- Limpeza externa;<br>- Limpeza interna;<br>- Reaperto em contatos e bornes;<br>- Diagnostico de irregularidades em circuito eletrônico, a partir da análise dos componentes;<br>- Checar funcionamento de componentes semicondutores e afins;<br>- Trocar componentes danificados por novos;<br>- Checar fixação de todos os componentes;<br>- Testar funcionamento dos equipamentos após as trocas e/ou adaptações.<br>B. Realização de serviços gerais de manutenção pneumática, como:<br>- Reparo em válvulas solenoides, direcionais e manuais;<br>- Checagem de condições geral do equipamento;<br>- Reparo em cilindros pneumáticos;<br>- Checar vazamento ou passagens;<br>- Testar funcionamento dos componentes após o reparo</p><p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1784692,"hash":"L64XWY5R","position_name":"Técnico en Metrología Tridimensional (Semana)","description":"<p><strong>Puesto: Técnico en Metrología Tridimensional (Semana)</strong></p>\n<p><strong></strong><strong>Ubicación: Vigo, España</strong></p>\n<p><strong></strong><strong>Horario de trabajo: turno de 06h a 14h (lunes a viernes)﻿ - hasta finales de este año</strong></p>\n<p><br></p>\n<p>Nuestro cliente es una empresa global de tecnología que suministra productos y sistemas de movilidad avanzada para automóviles de pasajeros, vehículos comerciales y tecnología industrial. Su amplia gama de productos está dirigida principalmente a fabricantes de vehículos, proveedores de movilidad y startups en las áreas de transporte y movilidad.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsabilidades y Tareas del Puesto</strong></p>\n<ul><li>Calibrar y mantener los instrumentos de medición y los equipos de prueba, asegurando que se ajusten a las normas y especificaciones establecidas.</li><li>Realizar verificaciones periódicas y preventivas para garantizar la precisión y fiabilidad de los instrumentos de medición.</li><li>Medir componentes y productos utilizando diversos equipos de medición, como micrómetros, calibradores, comparadores ópticos, máquinas de medición por coordenadas (CMM), entre otros.</li><li>Inspeccionar piezas y productos durante y después de la fabricación para garantizar que se ajusten a las tolerancias y especificaciones técnicas.</li><li>Analizar los datos de medición y generar informes detallados sobre la conformidad de los productos.</li><li>Identificar desviaciones y no conformidades, sugiriendo acciones correctivas para resolver problemas de calidad.</li><li>Colaborar con los ingenieros de producción y otros departamentos para resolver problemas de calidad y mejorar los procesos de fabricación.</li><li>Proporcionar apoyo técnico y formación a los operadores de máquinas sobre el uso adecuado de los equipos de medición.</li><li>Participar en el desarrollo e implementación de nuevos procesos de medición y control de calidad.</li><li>Proponer mejoras en los métodos y procedimientos de medición para aumentar la eficacia y la precisión.</li><li>Mantener registros detallados de las calibraciones, inspecciones y mantenimiento de los equipos.</li><li>Garantizar que todas las actividades de medición y calibración cumplan con las normas internas y la regulación externa aplicable (ISO, ASME, etc.).</li><li>Participar en proyectos de desarrollo de nuevos productos y procesos, proporcionando apoyo metrológico desde la fase de diseño hasta la producción en serie.</li><li>Realizar estudios de repetibilidad y reproducibilidad (R&amp;R) para evaluar la precisión de los procesos de medición.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos</strong></p>\n<ul><li>Amplio conocimiento en el uso de la máquina de medición por coordenadas con software <strong>Metrolog. CMM&nbsp;﻿- factor de eliminación</strong></li><li>Conocimientos profundos de metrología y principios de medición.</li><li>Familiaridad con instrumentos de medición avanzados y equipos de calibración.</li><li>Conocimiento de las normas y regulaciones aplicables a la metrología y control de calidad.</li><li>Capacidad para interpretar dibujos y especificaciones técnicas.</li><li>Competencia para analizar datos de medición y generar informes precisos.</li><li>Alto nivel de precisión y cuidado en los procesos de medición e inspección.</li><li>Capacidad para identificar y corregir errores menores que puedan afectar la calidad del producto.</li><li>Formación técnica en metrología, ingeniería de producción, ingeniería mecánica o áreas relacionadas.</li><li>Experiencia previa en un entorno de fabricación, preferiblemente en el sector automotriz.</li><li>Trabajo en laboratorios de metrología y entornos de producción.</li><li>Uso de software especializado para el análisis de datos y control de calidad.</li><li>Cumplimiento de estrictas normas de seguridad y calidad, garantizando la protección tanto del técnico como de la integridad de los productos.</li><li>Fluidez en español; Se valora inglés.﻿</li></ul>","country":"Spain","state":"","city":"Vigo","address":"","zipcode":"","location_display":"Vigo, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1831369,"hash":"L76VW39X","position_name":"Técnico Postventa (Gestion Residencial)","description":"<p>Nos encontramos en la búsqueda de un perfil&nbsp;de técnico de posventa, con experiencia de 2-3 años en gestión de posventa o incidencias privativas en el seno del equipo de Operaciones de una importante empresa gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p>\n<ul><li>Experiencia a pie de obra</li><li>Responsable de gestionar la posventa de los edificios de Plan Vive</li><li>Sería la persona que recibe las incidencias de los inquilinos y supervisa que la constructora ejecuta y da respuesta a todas ellas</li><li>Daría adicionalmente apoyo en los checks iniciales de las viviendas</li></ul>\n<p>Plan de crecimiento interno en la compañía y beneficios que acompañen tu día a día. Si tu perfil encaja en la posición no dudes en inscribirte en la oferta!</p>\n<p></p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1785293,"hash":"L764XX95","position_name":"Técnicos de Manutenção","description":"<p><strong>Descrição da Função: Técnicos de Manutenção (níveis 4 e 5)</strong></p>\n<p><strong>Localização: Lanheses, Viana do Castelo</strong></p>\n<p><strong>Horário de trabalho:</strong></p><ul><li><strong>Turnos fixos semana (06h-14h e 14h-22h)</strong></li><li><strong>﻿﻿Turnos 12h fim de semana (Sábado e Domingo, 18h-06h)<br></strong></li></ul>\n<p><br></p>\n<p>A PTC está a recrutar Técnicos de Manutenção para um cliente do setor automotivo. Esta empresa apoio a indústria automotiva em soluções tecnológicas eficientes para veículos leves, médios e pesados, bem como para aplicações fora de estrada.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsabilidades:</strong></p>\n<ul><li><strong>﻿</strong>Realizar tarefas de manutenção mecânica, corretiva e preventiva de produção, máquinas e instalações de linhas de montagem automatizadas.</li><li>Tarefas de manutenção como programador robótico (KUKA e ABB) e PLC</li><li>Tarefas de manutenção elétrica, pneumática e hidráulica</li><li>Gestão de&nbsp;pedidos de peças de reposição.</li></ul>\n<p><strong><br>Requisitos:</strong></p>\n<ul><li>Mecânico industrial com mais de 5 anos de experiência em manutenção e reparo de máquinas.</li><li>Formação profissional/técnica, preferencialmente na área de mecânica industrial, sendo valorizados conhecimentos de hidráulica, pneumática, soldadura robótica, programação, Siemens, etc.</li><li>Experiência de produto com peças de submontagem metálica (Chapa, Estampagem, Maquinação, etc.).</li><li>Experiência no setor Automotivo em projetos Tier-1 ou OEM.</li><li>Serão valorizados capacidade organizacional, planeamento, conhecimentos de Lean Manufacturing, TPM e gestão de indicadores.</li><li>Idiomas: Português ou Espanhol;&nbsp;Inglês (Básico)</li><li>Fortes competências de resolução de problemas, criatividade e vontade de pensar fora da caixa.</li><li>Capacidade de gerir e comunicar-se com equipas multifuncionais de forma eficiente.</li><li>Competências excepcionais de comunicação verbal e escrita.</li><li>Boa capacidade de negociação, gestão de conflitos e resolução.</li><li>Capacidade de adaptação rápida ao cliente.﻿</li></ul>","country":"Portugal","state":"Viana do Castelo District","city":"Viana do Castelo","address":"","zipcode":"","location_display":"Viana do Castelo, Viana do Castelo District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1753797,"hash":"QVXW756R","position_name":"Tenant Relationship Manager","description":"<p>Nos encontramos en la búsqueda de&nbsp;﻿un Responsable de Atención al Inquilino en el seno del equipo de Operaciones de una&nbsp;empresa gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Este perfil formará parte de un equipo de atención al cliente encargado de gestionar las siguientes tareas principales:</span><br></p>\n<ul><li>Onboarding de Clientes (que incluye la formalización documental asociada y el seguimiento de expedientes)</li><li>Encuestas periódicas de satisfacción</li><li>Gestión de cambios y renovaciones</li><li>Gestión de bajas, trámites de despedida y cierre de expedientes</li><li>Gestión de servicios privativos</li><li>Gestión de incidencias técnicas y administrativas a través de la plataforma de incidencias y el centro de llamadas (identificación del nivel de gravedad de la incidencia, responsables de la resolución, seguimiento del proceso hasta el cierre de la incidencia, optimización de tiempos, etc.)</li></ul>\n<p>Reportará directamente al Responsable del área comercial de la empresa y deberá interactuar constantemente con los departamentos de Property Management y Facility Management para asegurarse de que toda la información proveniente de los inquilinos se gestione correctamente.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Se requiere dominio de herramientas de ofimática.&nbsp;</span><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿Si crees que puedes encajar en esta posición no dudes en apuntarte a la oferta!</span></p><p><br></p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828778,"hash":"L4Y6V85V","position_name":"Test Bench Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Test Bench Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in dynamic and static test benches on electric motors, specifically at the end of component assembly lines</li><li>Knowledge of the electrical/electrotechnical field<br></li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Pitești","address":"","zipcode":"","location_display":"Pitești, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1925565,"hash":"L39Y46XV","position_name":"Vehicle Industrialization  Engineer (Compliance Convergence Assurance)","description":"<p><strong>Job Title: Vehicle <strong>Industrialization </strong>Engineer (<strong>Compliance Convergence Assurance)</strong>﻿</strong></p>\n<p><br></p>\n<p><strong></strong><strong><strong>Company Description: </strong></strong>Our client is a renowned company in the automotive sector, recognized for its innovation and excellence in the assembly of vehicle components.﻿</p>\n<p><br></p>\n<p><strong>﻿﻿Location:&nbsp;</strong>General activity will follow the work schedule of the Valladolid factory, typically in the morning.</p>\n<p><br></p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Ensure the convergence of Product, Process, and Technical Definition of the vehicle series.</li><li>Oversee AVES (Automotive Vehicle Evaluation System) convergence.</li><li>Manage geometric convergence.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Resolve numerical RCC (standard design), sectoral, and wiring issues; respond to action requests on open problems from the Customer Performance Pilot (PPC); ensure assemblability and AVES.</li><li>Complete TOP SERIES reports (presenting the maturity level of new parts).</li><li>Ensure AVES convergence of the vehicle.</li><li>Ensure geometric convergence of the finished vehicle within its architectural perimeter (TCM indicators and geometric balance over the ring) and conduct Geo meetings.</li><li>Remove all reservations from the TOP SERIES between PPC milestones and SOP.</li><li>Report project progress to the assembly project manager (CPM), disseminate the PCC dashboard, and participate in IP+, RAP, CCS, QRR, COMODIF meetings; present critical points in PQE.</li><li>Implement product modifications before the SOP milestone to meet factory goals in quality, productivity, safety, and ergonomics.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Skills and Knowledge:</strong></p>\n<ul><li>Understanding of automotive design, 3D numerical concept analysis, basic manufacturing, and assembly processes.</li><li>Intermediate, advanced or proficiency in&nbsp;Spanish&nbsp;(spoken and written) - mandatory.</li><li>Proficiency in English (spoken and written) - mandatory.</li><li>Proficiency in French (spoken and written) - preferencial.</li></ul>\n<p>  </p>\n<p><strong><br></strong></p>\n<p><strong>Requirements:</strong></p>\n<ul><li>Proficiency with design tools (Catia V5/V6): Specialist, very knowledgeable.<br></li><li>Ability to read and interpret plans and related standards: Specialist, very knowledgeable.</li><li>Product design and development in the automotive sector: Specialist, very knowledgeable.</li><li>Demonstrated expertise with 3 years of service in automotive manufacturing processes: Specialist, very knowledgeable.</li><li>Cross-functional animation, synthesis, presentation, negotiation, and organization skills: Senior, could train others.</li><li>Demonstrated expertise with 3 years of service in an industrial automotive factory environment: Senior, could train others.</li><li>Dimensional chain analysis: Specialist, very knowledgeable.</li><li>Office tools proficiency (EXCEL, POWERPOINT, WORD, ONE-NOTE): Autonomous.</li></ul>","country":"Spain","state":"","city":"Valladolid","address":"","zipcode":"","location_display":"Valladolid, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:06:59 GMT
+        {"count":164,"next":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=17","previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=15","results":[{"id":1959790,"hash":"L4Y57RY5","position_name":"System Administrator (Solaris)","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">A PTC Group está a recrutar um System Administrator para reforçar a nossa equipa, em regime híbrido.</span></p>\n<p>Este Administrator será responsável por:</p>\n<p><strong><strong>Responsabilidades:</strong></strong></p>\n<ul><li>Fazer o processo de gestão (suporte, análise, evolução e implementação) da infraestrutura Solaris.</li><li>Supervisionar o desempenho do sistema e realizar ajustes conforme necessário para garantir a eficiência e estabilidade do sistema.</li><li>Criar, modificar e eliminar contas de utilizador, configurar permissões e grupos de utilizadores, e garantir que as políticas de segurança sejam seguidas para proteger os dados e recursos do sistema.</li><li>Analisar e executar atividades de automação baseadas em Ansible e Scripting (Shell).</li></ul>\n<ul></ul>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li>Formação, Licenciatura ou Mestrado em Engenharia Informática, Computer Science ou similar.</li><li>Experiência mínima de +2 anos como System Administrator</li><li>Experiência mínima de +1 ano com sistemas Solaris</li><li>Conhecimentos em armazenamento e backups&nbsp;(EMC, SUN, Clarion)</li></ul>","country":"Portugal","state":"","city":"Lisbon","address":"","zipcode":"","location_display":"Lisbon, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1751556,"hash":"L64W644W","position_name":"Team Leader Accounts Receivable","description":"<p><strong>Vaga: Team Leader Accounts Receivable</strong></p>\n<p><strong>Localização: Cacia, Aveiro</strong></p>\n<p><br>﻿O nosso cliente é um parceiro global de inovação e soluções, fabricando necessidades de energia de combustíveis alternativos e de baixa emissão. A sua missão é fornecer soluções de powertrain de próxima geração à medida que os mercados em todo o mundo fazem a transição para um futuro mais sustentável.<br>﻿<br>﻿<strong><br>﻿Responsabilidades:</strong></p>\n<p>Esta pessoa vai reportar ao responsável pela Contabilidade e apoiará a área de Contas a Receber do nosso cliente. Estima-se que cerca de 3.500 a 4.000 faturas devam ser processadas por mês.</p>\n<ul><li>Coordena o fluxo de trabalho para o departamento de acompanhamento/ faturação.&nbsp;</li><li>Atribui trabalho à equipa de Contas a Receber.&nbsp;</li><li>Acompanha as próprias contas/devedores em processo.&nbsp;</li><li>Assegura diretamente que todas as reclamações negadas ou rejeitadas são acompanhadas e tratadas de forma atempada.&nbsp;</li><li>Verifica aleatoriamente o trabalho para garantir precisão, eficiência e uniformidade.&nbsp;</li><li>Responde às questões da equipa de forma atempada, garantindo que compreendem completamente como desempenhar as suas funções.\nOrienta e treina a equipa.&nbsp;</li><li>Forma novos funcionários e funcionários existentes em técnicas.&nbsp;</li><li>Identifica proativamente tendências e inicia recomendações de mudança para o Gestor.&nbsp;</li><li>Fornece acompanhamento e gestão de fluxo de trabalho.&nbsp;</li><li>Exerce julgamento para tomar decisões sobre métodos e técnicas selecionadas para obter soluções.&nbsp;</li><li>Promove o trabalho em equipa, mantendo-se disponível para ajudar a equipa conforme necessário.&nbsp;</li><li>Lançamento de faturas de despesas gerais</li></ul>\n<p>﻿<strong>﻿<br>﻿Requisitos:</strong></p>\n<ul><li>Licenciatura ou Mestrado em Contabilidade, Finanças, Administração e Gestão de Empresas, Ciências Empresariais, ou áreas semelhantes.</li><li>Experiência profissional: + de 5 anos&nbsp;na área. </li><li>Experiência em shared services.</li><li>Idiomas: Português nativo;&nbsp;Inglês fluente (comunicação regular com países estrangeiros).</li><li>Experiência em SAP S/4HANA e Excel.</li><li>Trabalho presencial em Aveiro</li></ul>","country":"Portugal","state":"Aveiro District","city":"Cacia","address":"","zipcode":"","location_display":"Cacia, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1804073,"hash":"QVXYWWY8","position_name":"Técnico de Automação Industrial (PLC Siemens) - FRANÇA","description":"<p><strong>Posição:&nbsp;﻿Técnico de Automação Industrial (PLC Siemens)</strong></p>\n<p><strong>Localização: Rouen, Normandia, França</strong></p>\n<p><strong>Duração: &gt;3 meses</strong></p>\n<p><br></p>\n<p>A PTC Group está a recrutar para uma&nbsp;empresa é líder mundial em cabos e sistemas para energia e telecomunicações, oferecendo uma vasta gama de produtos, incluindo cabos subterrâneos e submarinos, sistemas de transmissão e soluções de conectividade para transmissão de voz, vídeo e dados.﻿</p>\n<p>﻿<strong><br></strong></p>\n<p><strong>﻿Responsabilidades:</strong><br></p>\n<ul><li> Programar e configurar PLCs Siemens para o controlo e automação de processos industriais.</li><li> Realizar a manutenção preventiva e corretiva de sistemas automatizados.</li><li> Diagnosticar e resolver problemas técnicos relacionados com automação.</li><li> Colaborar com outros departamentos para melhorar a eficiência e qualidade dos processos.</li><li> Documentar procedimentos e atualizações de sistemas.</li><li> Assegurar o cumprimento das normativas de segurança e qualidade.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos:</strong></p>\n<ul><li> Diploma técnico ou universitário em Automação, Eletrónica, Mecatrónica ou área relacionada.</li><li> Mínimo de 3 anos de experiência em programação e manutenção de sistemas de automação Siemens.</li><li> Conhecimento profundo de PLC Siemens (S7-1200, S7-1500), HMI e sistemas SCADA.</li><li> Experiência em integração de sistemas e comunicação industrial (Profibus, Profinet, etc.).</li><li> Capacidade para interpretar esquemas elétricos e planos de automação.</li><li> Capacidade de trabalhar de forma independente e em equipa.</li><li> Excelentes capacidades de resolução de problemas e atenção aos detalhes.</li><li> Disponibilidade para trabalhar em horários flexíveis e realizar deslocações ocasionais conforme as necessidades do projeto.</li><li>Ter cidadania europeia.</li><li> Idiomas: Inglês (Fluente) OU Francês (Fluente)</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Informação adicional:</strong></p>\n<ul><li>﻿﻿Duração: pelo menos&nbsp;3 meses<br></li><li>Salário competitivo baseado na experiência do candidato.</li><li> Compensação por deslocalização na França.</li><li> Contratação imediata.</li></ul>","country":"France","state":"Normandy","city":"Rouen","address":"","zipcode":"","location_display":"Rouen, Normandy, France","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1833543,"hash":"L5398V5R","position_name":"Técnico de Automatismos﻿ Júnior","description":"<p><strong>Posição:&nbsp;﻿Técnico de Automatismos﻿ Júnior</strong></p>\n<p><strong>Localização: Portugal</strong></p>\n<p></p>\n<p>Estamos a procurar um Técnico de Automatismos Júnior para o nosso cliente localizado em Vigo, que desenvolve soluções seguras, eficientes, inteligentes e potentes para a automação de fábricas, aplicações móveis, aplicações de maquinaria e engenharia. </p>\n<p>Esta é uma grande oportunidade numa grande empresa multinacional, com um bom ambiente de trabalho e oportunidade para desenvolvimento profissional.</p>\n<p><strong>Procuramos uma pessoa que esteja localizada em Portugal Continental, com disponibilidade para realizar a formação inicial de 3 a 6 meses em Vigo, sendo o trabalho efetuado posteriormente em regime híbrido (em Portugal, nos clientes do nosso cliente).</strong></p>\n<p><strong><br></strong></p>\n<p><strong>Tarefas e responsabilidades:</strong></p>\n<ul><li>Criação e redação dos padrões de compra a nível de Automatismos, Robótica e Mecânica.</li><li>Pilotagem de Projetos de Automatismos, Robótica e Mecânica na área de montagem (Fase de Preparação, Fase de Estudos, Fase de Montagem, Fase de Arranque e Aumento de Cadência).</li><li>Coordenação, gestão, controlo de trabalhos das subcontratas a nível de qualidade, prazos e segurança.</li><li>Análise técnica de todos os programas de autómatos e periféricos e da documentação.</li><li>Verificação do cumprimento de padrões, funcionalidades e desempenho operacional exigido.</li><li>Realização de esquemas elétricos e/ou pneumáticos.</li><li>Acompanhamento de montagens elétricas e/ou pneumáticas.</li><li>Programação de autómatos (Siemens, Schneider, Rockwell...) e telas IHM.</li><li>Arranque de maquinaria e/ou instalações.</li><li>Reporte das incidências pertinentes aos responsáveis.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos:</strong></p>\n<ul><li>Estudos mínimos: Curso Técnico de Nível Superior em Automação e Robótica Industrial ou Eletricidade.</li><li>Valorizamos experiência em programação de autómatos, elaboração de esquemas eléctricos,&nbsp;programação robótica.﻿</li><li>Valorizamos conhecimentos do idioma inglês.</li><li>Valorizamos a atitude do candidato em aprender e melhorar acima da sua experiência ou conhecimentos prévios.</li></ul>","country":"Portugal","state":"Aveiro District","city":"Oliveira de Azeméis","address":"","zipcode":"","location_display":"Oliveira de Azeméis, Aveiro District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1938321,"hash":"L7635873","position_name":"Técnico de Instalação Júnior (Sistemas de Visão Computacional)","description":"<p><strong>Posição: Técnico de Instalação Júnior (Sistemas de Visão Computacional)</strong></p>\n<p><strong>Localização: Guimarães (100% presencial)</strong></p>\n<p><br></p>\n<p><strong></strong>A PTC está a recrutar um técnico de instalação de sistemas de visão computacional para uma empresa localizada em Guimarães. É uma&nbsp;empresa especialista em visão artificial,&nbsp;integrando sistemas em rede segundo as guidelines da<strong> indústria 4.0</strong>, para a&nbsp;<strong>automatização de processos</strong>.</p>\n<p><br></p>\n<p><strong><strong>Responsabilidades</strong></strong></p>\n<ul>\n <li>Levantamento de requisitos do cliente</li>\n <li>Instalação, configuração e parametrização de equipamentos de visão      artificial (computadores, câmaras industriais, lentes, leds)</li>\n <li>Manutenção de sistemas em ambiente de produção</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos</strong></p>\n<ul>\n <li>Curso técnico ou geral relacionado com as áreas de      eletrónica ou automação.</li>\n <li>Experiência +1 anos na implementação de soluções automatizadas e contacto com processos produtivos na indústria.﻿</li><li>Conhecimentos básicos de matemática, lógica,      linguagens de programação. </li>\n <li>Conhecimentos básicos de eletrónica e informática. </li>\n <li>Conhecimentos em visão computacional é um extra.</li>\n <li>Idiomas: português nativo.</li></ul>","country":"Portugal","state":"","city":"Guimaraes","address":"","zipcode":"","location_display":"Guimaraes, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1784680,"hash":"L64XWY4R","position_name":"Técnico de Metrologia Tridimensional (Fins de Semana)","description":"<p><strong>Posição:&nbsp;﻿Técnico de Metrologia Tridimensional (Fins de Semana)</strong></p>\n<p><strong>﻿Localização: Vila Nova de Cerveira, Viana do Castelo<br></strong></p>\n<p><strong>﻿Regime de trabalho:&nbsp;﻿turnos de 12h/dia (sábados e domingos),&nbsp;﻿com início às 06h ou 09h da manhã - até final deste ano<br></strong></p>\n<p><strong>﻿</strong><br></p>\n<p>O nosso cliente é uma empresa global de tecnologia que fornece produtos e sistemas de mobilidade avançada para automóveis de passageiros, veículos comerciais e tecnologia industrial. A sua vasta gama de produtos destina-se principalmente a fabricantes de veículos, fornecedores de mobilidade e startups nas áreas de transporte e mobilidade.</p>\n<p><br></p>\n<p><strong></strong><strong><strong>Responsabilidades e Tarefas da Função</strong></strong></p>\n<ul><li><strong><strong>﻿</strong></strong>Calibrar e manter os instrumentos de medição e os equipamentos de teste, assegurando que se ajustam às normas e especificações estabelecidas.</li><li>Realizar verificações periódicas e preventivas para garantir a precisão e fiabilidade dos instrumentos de medição.</li><li>Medir componentes e produtos utilizando diversos equipamentos de medição, como micrómetros, calibres, comparadores ópticos, máquinas de medição por coordenadas (MMC), entre outros.</li><li>Inspecionar peças e produtos durante e após a fabricação para garantir que se ajustam às tolerâncias e especificações técnicas.</li><li>Analisar os dados de medição e gerar relatórios detalhados sobre a conformidade dos produtos.</li><li>Identificar desvios e não conformidades, sugerindo ações corretivas para resolver problemas de qualidade.</li><li>Colaborar com os engenheiros de produção e outros departamentos para resolver problemas de qualidade e melhorar os processos de fabricação.</li><li>Proporcionar apoio técnico e formação aos operadores de máquinas sobre o uso adequado dos equipamentos de medição.</li><li>Participar no desenvolvimento e implementação de novos processos de medição e controlo de qualidade.</li><li>Propor melhorias nos métodos e procedimentos de medição para aumentar a eficácia e a precisão.</li><li>Manter registos detalhados das calibrações, inspeções e manutenção dos equipamentos.</li><li>Garantir que todas as atividades de medição e calibração cumprem as normas internas e a regulamentação externa aplicável (ISO, ASME, etc.).</li><li>Participar em projetos de desenvolvimento de novos produtos e processos, proporcionando apoio metrológico desde a fase de conceção até à produção em série.</li><li>Realizar estudos de repetibilidade e reprodutibilidade (R&amp;R) para avaliar a precisão dos processos de medição</li></ul>\n<p><br></p>\n<p><strong><strong>Requisitos:</strong></strong></p>\n<ul><li><strong><strong></strong></strong>Elevado conhecimento na utilização da máquina de medição por coordenadas com software <strong>Metrolog. CMM - fator eliminatório</strong></li><li><strong></strong>Conhecimentos profundos de metrologia e princípios de medição.</li><li>Familiaridade com instrumentos de medição avançados e equipamentos de calibração.</li><li>Conhecimento das normas e regulamentos aplicáveis à metrologia e controlo de qualidade.</li><li>Capacidade para interpretar desenhos e especificações técnicas.</li><li>Competência para analisar dados de medição e gerar relatórios precisos.</li><li>Elevado nível de precisão e cuidado nos processos de medição e inspeção.</li><li>Capacidade para identificar e corrigir erros menores que possam afetar a qualidade do produto.</li><li>Formação técnica em metrologia, engenharia de produção, engenharia mecânica ou áreas relacionadas.</li><li>Experiência prévia num ambiente de fabricação, preferencialmente no setor automóvel.</li><li>Trabalho em laboratórios de metrologia e ambientes de produção.</li><li>Utilização de software especializado para a análise de dados e controlo de qualidade.</li><li>Cumprimento de rigorosas normas de segurança e qualidade, garantindo a proteção tanto do técnico como da integridade dos produtos</li><li>Fluência no idioma Português; inglês valorizado.</li></ul>","country":"Portugal","state":"Viana do Castelo District","city":"Vila Nova de Cerveira","address":"","zipcode":"","location_display":"Vila Nova de Cerveira, Viana do Castelo District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"part_time","is_pinned_in_career_page":false},{"id":1658255,"hash":"L5735335","position_name":"Técnico de Segurança do Trabalho","description":"<p>A PTC Group está em busca de&nbsp;um&nbsp;Técnico em Segurança do Trabalho&nbsp;para Maceió-AL<br><br></p>\n<p><strong><strong>Requisitos Obrigatórios</strong></strong><br></p>\n<p><br></p>\n<ul><li>Técnico em Segurança do Trabalho com Registro no MTE;</li><li>Conhecimento em Normas Regulamentadoras;</li><li>Conhecimento em pacote office.</li></ul>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p><br></p>\n<p></p>","country":"Brazil","state":"AL","city":"Maceió","address":"","zipcode":"","location_display":"Maceió, AL, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1755156,"hash":"L64W454W","position_name":"Técnico Eletrônico","description":"<p><span style=\"font-family: inherit; font-size: 0.875rem;\">Técnico Eletrônico: com experiência mínima, comprovada em carteira, de 4 anos, curso</span></p>\n<p>referente a NR-10. O mesmo deve possuir conhecimentos em reparos de placas de</p>\n<p>circuito eletrônico de inversores, fontes de alimentação e outros equipamentos, digitais e analógicas, com a utilização de osciloscópio, multímetro, estação de retrabalho e afins; Com experiência mínima, comprovada em carteira, de 4 anos em manutenção em bancada de equipamentos de máquinas industriais;</p>\n<p>﻿<br></p>\n<p>﻿Escopo de atividades:<br></p>\n<p>﻿﻿Faz parte do escopo de serviço as seguintes atividades:<br>A. Realização de serviços gerais de manutenção elétrica e eletrônica, como:<br>- Limpeza externa;<br>- Limpeza interna;<br>- Reaperto em contatos e bornes;<br>- Diagnostico de irregularidades em circuito eletrônico, a partir da análise dos componentes;<br>- Checar funcionamento de componentes semicondutores e afins;<br>- Trocar componentes danificados por novos;<br>- Checar fixação de todos os componentes;<br>- Testar funcionamento dos equipamentos após as trocas e/ou adaptações.<br>B. Realização de serviços gerais de manutenção pneumática, como:<br>- Reparo em válvulas solenoides, direcionais e manuais;<br>- Checagem de condições geral do equipamento;<br>- Reparo em cilindros pneumáticos;<br>- Checar vazamento ou passagens;<br>- Testar funcionamento dos componentes após o reparo</p><p></p>","country":"Brazil","state":"BA","city":"Camaçari","address":"","zipcode":"","location_display":"Camaçari, BA, Brazil","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1784692,"hash":"L64XWY5R","position_name":"Técnico en Metrología Tridimensional (Semana)","description":"<p><strong>Puesto: Técnico en Metrología Tridimensional (Semana)</strong></p>\n<p><strong></strong><strong>Ubicación: Vigo, España</strong></p>\n<p><strong></strong><strong>Horario de trabajo: turno de 06h a 14h (lunes a viernes)﻿ - hasta finales de este año</strong></p>\n<p><br></p>\n<p>Nuestro cliente es una empresa global de tecnología que suministra productos y sistemas de movilidad avanzada para automóviles de pasajeros, vehículos comerciales y tecnología industrial. Su amplia gama de productos está dirigida principalmente a fabricantes de vehículos, proveedores de movilidad y startups en las áreas de transporte y movilidad.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsabilidades y Tareas del Puesto</strong></p>\n<ul><li>Calibrar y mantener los instrumentos de medición y los equipos de prueba, asegurando que se ajusten a las normas y especificaciones establecidas.</li><li>Realizar verificaciones periódicas y preventivas para garantizar la precisión y fiabilidad de los instrumentos de medición.</li><li>Medir componentes y productos utilizando diversos equipos de medición, como micrómetros, calibradores, comparadores ópticos, máquinas de medición por coordenadas (CMM), entre otros.</li><li>Inspeccionar piezas y productos durante y después de la fabricación para garantizar que se ajusten a las tolerancias y especificaciones técnicas.</li><li>Analizar los datos de medición y generar informes detallados sobre la conformidad de los productos.</li><li>Identificar desviaciones y no conformidades, sugiriendo acciones correctivas para resolver problemas de calidad.</li><li>Colaborar con los ingenieros de producción y otros departamentos para resolver problemas de calidad y mejorar los procesos de fabricación.</li><li>Proporcionar apoyo técnico y formación a los operadores de máquinas sobre el uso adecuado de los equipos de medición.</li><li>Participar en el desarrollo e implementación de nuevos procesos de medición y control de calidad.</li><li>Proponer mejoras en los métodos y procedimientos de medición para aumentar la eficacia y la precisión.</li><li>Mantener registros detallados de las calibraciones, inspecciones y mantenimiento de los equipos.</li><li>Garantizar que todas las actividades de medición y calibración cumplan con las normas internas y la regulación externa aplicable (ISO, ASME, etc.).</li><li>Participar en proyectos de desarrollo de nuevos productos y procesos, proporcionando apoyo metrológico desde la fase de diseño hasta la producción en serie.</li><li>Realizar estudios de repetibilidad y reproducibilidad (R&amp;R) para evaluar la precisión de los procesos de medición.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Requisitos</strong></p>\n<ul><li>Amplio conocimiento en el uso de la máquina de medición por coordenadas con software <strong>Metrolog. CMM&nbsp;﻿- factor de eliminación</strong></li><li>Conocimientos profundos de metrología y principios de medición.</li><li>Familiaridad con instrumentos de medición avanzados y equipos de calibración.</li><li>Conocimiento de las normas y regulaciones aplicables a la metrología y control de calidad.</li><li>Capacidad para interpretar dibujos y especificaciones técnicas.</li><li>Competencia para analizar datos de medición y generar informes precisos.</li><li>Alto nivel de precisión y cuidado en los procesos de medición e inspección.</li><li>Capacidad para identificar y corregir errores menores que puedan afectar la calidad del producto.</li><li>Formación técnica en metrología, ingeniería de producción, ingeniería mecánica o áreas relacionadas.</li><li>Experiencia previa en un entorno de fabricación, preferiblemente en el sector automotriz.</li><li>Trabajo en laboratorios de metrología y entornos de producción.</li><li>Uso de software especializado para el análisis de datos y control de calidad.</li><li>Cumplimiento de estrictas normas de seguridad y calidad, garantizando la protección tanto del técnico como de la integridad de los productos.</li><li>Fluidez en español; Se valora inglés.﻿</li></ul>","country":"Spain","state":"","city":"Vigo","address":"","zipcode":"","location_display":"Vigo, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1831369,"hash":"L76VW39X","position_name":"Técnico Postventa (Gestion Residencial)","description":"<p>Nos encontramos en la búsqueda de un perfil&nbsp;de técnico de posventa, con experiencia de 2-3 años en gestión de posventa o incidencias privativas en el seno del equipo de Operaciones de una importante empresa gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p>\n<ul><li>Experiencia a pie de obra</li><li>Responsable de gestionar la posventa de los edificios de Plan Vive</li><li>Sería la persona que recibe las incidencias de los inquilinos y supervisa que la constructora ejecuta y da respuesta a todas ellas</li><li>Daría adicionalmente apoyo en los checks iniciales de las viviendas</li></ul>\n<p>Plan de crecimiento interno en la compañía y beneficios que acompañen tu día a día. Si tu perfil encaja en la posición no dudes en inscribirte en la oferta!</p>\n<p></p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:46 GMT
+- request:
+    method: get
+    uri: https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=17
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jul 2024 16:28:46 GMT
+      Content-Type:
+      - application/json
+      Content-Length:
+      - '10942'
+      Connection:
+      - keep-alive
+      Server:
+      - gunicorn
+      Allow:
+      - GET, HEAD, OPTIONS
+      Content-Security-Policy:
+      - 'default-src https: data: blob: ''unsafe-eval'' ''unsafe-inline''; object-src
+        ''none'''
+      X-Frame-Options:
+      - SAMEORIGIN
+      Vary:
+      - Accept-Language, Cookie, Origin
+      Content-Language:
+      - en
+      Strict-Transport-Security:
+      - max-age=31536000
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        {"count":164,"next":null,"previous":"https://core.api.manatal.com/open/v3/career-page/ptc-group/jobs/?page=16","results":[{"id":1785293,"hash":"L764XX95","position_name":"Técnicos de Manutenção","description":"<p><strong>Descrição da Função: Técnicos de Manutenção (níveis 4 e 5)</strong></p>\n<p><strong>Localização: Lanheses, Viana do Castelo</strong></p>\n<p><strong>Horário de trabalho:</strong></p><ul><li><strong>Turnos fixos semana (06h-14h e 14h-22h)</strong></li><li><strong>﻿﻿Turnos 12h fim de semana (Sábado e Domingo, 18h-06h)<br></strong></li></ul>\n<p><br></p>\n<p>A PTC está a recrutar Técnicos de Manutenção para um cliente do setor automotivo. Esta empresa apoio a indústria automotiva em soluções tecnológicas eficientes para veículos leves, médios e pesados, bem como para aplicações fora de estrada.</p>\n<p><strong><br></strong></p>\n<p><strong>Responsabilidades:</strong></p>\n<ul><li><strong>﻿</strong>Realizar tarefas de manutenção mecânica, corretiva e preventiva de produção, máquinas e instalações de linhas de montagem automatizadas.</li><li>Tarefas de manutenção como programador robótico (KUKA e ABB) e PLC</li><li>Tarefas de manutenção elétrica, pneumática e hidráulica</li><li>Gestão de&nbsp;pedidos de peças de reposição.</li></ul>\n<p><strong><br>Requisitos:</strong></p>\n<ul><li>Mecânico industrial com mais de 5 anos de experiência em manutenção e reparo de máquinas.</li><li>Formação profissional/técnica, preferencialmente na área de mecânica industrial, sendo valorizados conhecimentos de hidráulica, pneumática, soldadura robótica, programação, Siemens, etc.</li><li>Experiência de produto com peças de submontagem metálica (Chapa, Estampagem, Maquinação, etc.).</li><li>Experiência no setor Automotivo em projetos Tier-1 ou OEM.</li><li>Serão valorizados capacidade organizacional, planeamento, conhecimentos de Lean Manufacturing, TPM e gestão de indicadores.</li><li>Idiomas: Português ou Espanhol;&nbsp;Inglês (Básico)</li><li>Fortes competências de resolução de problemas, criatividade e vontade de pensar fora da caixa.</li><li>Capacidade de gerir e comunicar-se com equipas multifuncionais de forma eficiente.</li><li>Competências excepcionais de comunicação verbal e escrita.</li><li>Boa capacidade de negociação, gestão de conflitos e resolução.</li><li>Capacidade de adaptação rápida ao cliente.﻿</li></ul>","country":"Portugal","state":"Viana do Castelo District","city":"Viana do Castelo","address":"","zipcode":"","location_display":"Viana do Castelo, Viana do Castelo District, Portugal","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1753797,"hash":"QVXW756R","position_name":"Tenant Relationship Manager","description":"<p>Nos encontramos en la búsqueda de&nbsp;﻿un Responsable de Atención al Inquilino en el seno del equipo de Operaciones de una&nbsp;empresa gestora de activos inmobiliarios especializada en rehabilitación de inmuebles y gestión de los mismos.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">Este perfil formará parte de un equipo de atención al cliente encargado de gestionar las siguientes tareas principales:</span><br></p>\n<ul><li>Onboarding de Clientes (que incluye la formalización documental asociada y el seguimiento de expedientes)</li><li>Encuestas periódicas de satisfacción</li><li>Gestión de cambios y renovaciones</li><li>Gestión de bajas, trámites de despedida y cierre de expedientes</li><li>Gestión de servicios privativos</li><li>Gestión de incidencias técnicas y administrativas a través de la plataforma de incidencias y el centro de llamadas (identificación del nivel de gravedad de la incidencia, responsables de la resolución, seguimiento del proceso hasta el cierre de la incidencia, optimización de tiempos, etc.)</li></ul>\n<p>Reportará directamente al Responsable del área comercial de la empresa y deberá interactuar constantemente con los departamentos de Property Management y Facility Management para asegurarse de que toda la información proveniente de los inquilinos se gestione correctamente.</p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">Se requiere dominio de herramientas de ofimática.&nbsp;</span><br></p><p><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿</span><span style=\"font-family: inherit; font-size: 0.875rem;\">﻿Si crees que puedes encajar en esta posición no dudes en apuntarte a la oferta!</span></p><p><br></p>","country":"Spain","state":"MD","city":"Madrid","address":"","zipcode":"","location_display":"Madrid, MD, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1828778,"hash":"L4Y6V85V","position_name":"Test Bench Equipment Coordinator (CAMI) - Process","description":"<p><strong>Job Title: Test Bench Equipment Coordinator (CAMI) - Process</strong></p>\n<p><strong>Location: Mioveni / Pitesti (Romania)</strong></p>\n<p></p>\n<p><strong>Company Description:</strong> Our client is a renowned company in the automotive sector, recognized for innovation and excellence in vehicle component assembly.</p>\n<p></p>\n<p><strong>Mission:</strong></p>\n<ul><li>Ensure the application of construction and safety standards</li><li>Foster good technical relationships with suppliers within their area of responsibility</li><li>Ensure proper physical receipt and integration of equipment</li><li>Guarantee that purchased equipment meets defined performance standards</li></ul>\n<p></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Formalize technical specifications and organize technical proposals with the Purchasing Department</li><li>Analyze the technical relevance of proposals in collaboration with Process Technology Specialists</li><li>Assist the Purchasing Department in commercial negotiations</li><li>Define project milestones, quality acquisition processes, and validation plans</li><li>Record, analyze, and formalize all elements requiring agreement and/or audit</li><li>Oversee the integration of equipment on the production line</li><li>Ensure the fine-tuning, startup, and debugging of production equipment</li><li>Ensure the integration of a product into an industrial process including machine/clamping piece/tools</li><li>Define the support plan for all process and manufacturing trades involved (learning, training)</li></ul>\n<p></p>\n<p><strong>Mandatory Requirements:</strong></p>\n<ul><li>Fluency in Romanian and English; working proficiency in French is a plus﻿</li><li>Experience in dynamic and static test benches on electric motors, specifically at the end of component assembly lines</li><li>Knowledge of the electrical/electrotechnical field<br></li><li>Years of experience: ideally between 5 to 10 years (molds, automotive, etc.)</li><li>May have higher education (mechanical engineering) or technical-vocational training</li><li>Resilient and communicative individual for factory floor functions, management, and external company contact.</li></ul>","country":"Romania","state":"AG","city":"Pitești","address":"","zipcode":"","location_display":"Pitești, AG, Romania","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false},{"id":1925565,"hash":"L39Y46XV","position_name":"Vehicle Industrialization  Engineer (Compliance Convergence Assurance)","description":"<p><strong>Job Title: Vehicle <strong>Industrialization </strong>Engineer (<strong>Compliance Convergence Assurance)</strong>﻿</strong></p>\n<p><br></p>\n<p><strong></strong><strong><strong>Company Description: </strong></strong>Our client is a renowned company in the automotive sector, recognized for its innovation and excellence in the assembly of vehicle components.﻿</p>\n<p><br></p>\n<p><strong>﻿﻿Location:&nbsp;</strong>General activity will follow the work schedule of the Valladolid factory, typically in the morning.</p>\n<p><br></p>\n<p><strong>Responsibilities:</strong></p>\n<ul><li>Ensure the convergence of Product, Process, and Technical Definition of the vehicle series.</li><li>Oversee AVES (Automotive Vehicle Evaluation System) convergence.</li><li>Manage geometric convergence.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Activities:</strong></p>\n<ul><li>Resolve numerical RCC (standard design), sectoral, and wiring issues; respond to action requests on open problems from the Customer Performance Pilot (PPC); ensure assemblability and AVES.</li><li>Complete TOP SERIES reports (presenting the maturity level of new parts).</li><li>Ensure AVES convergence of the vehicle.</li><li>Ensure geometric convergence of the finished vehicle within its architectural perimeter (TCM indicators and geometric balance over the ring) and conduct Geo meetings.</li><li>Remove all reservations from the TOP SERIES between PPC milestones and SOP.</li><li>Report project progress to the assembly project manager (CPM), disseminate the PCC dashboard, and participate in IP+, RAP, CCS, QRR, COMODIF meetings; present critical points in PQE.</li><li>Implement product modifications before the SOP milestone to meet factory goals in quality, productivity, safety, and ergonomics.</li></ul>\n<p><strong><br></strong></p>\n<p><strong>Skills and Knowledge:</strong></p>\n<ul><li>Understanding of automotive design, 3D numerical concept analysis, basic manufacturing, and assembly processes.</li><li>Intermediate, advanced or proficiency in&nbsp;Spanish&nbsp;(spoken and written) - mandatory.</li><li>Proficiency in English (spoken and written) - mandatory.</li><li>Proficiency in French (spoken and written) - preferencial.</li></ul>\n<p>  </p>\n<p><strong><br></strong></p>\n<p><strong>Requirements:</strong></p>\n<ul><li>Proficiency with design tools (Catia V5/V6): Specialist, very knowledgeable.<br></li><li>Ability to read and interpret plans and related standards: Specialist, very knowledgeable.</li><li>Product design and development in the automotive sector: Specialist, very knowledgeable.</li><li>Demonstrated expertise with 3 years of service in automotive manufacturing processes: Specialist, very knowledgeable.</li><li>Cross-functional animation, synthesis, presentation, negotiation, and organization skills: Senior, could train others.</li><li>Demonstrated expertise with 3 years of service in an industrial automotive factory environment: Senior, could train others.</li><li>Dimensional chain analysis: Specialist, very knowledgeable.</li><li>Office tools proficiency (EXCEL, POWERPOINT, WORD, ONE-NOTE): Autonomous.</li></ul>","country":"Spain","state":"","city":"Valladolid","address":"","zipcode":"","location_display":"Valladolid, Spain","is_salary_visible":false,"is_remote":null,"contract_details":"full_time","is_pinned_in_career_page":false}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:46 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Stockholm,%20Sweden?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -948,7 +994,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:59 GMT
+      - Tue, 30 Jul 2024 16:28:46 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -966,18 +1012,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 7005f1af68b34d4eadafa3a37a7afad8
+      - 291d24c5626333dbccba64ca606917b4
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75bb388274436bc73a46174486849|Ref A: BE189130952545139FC3E142571043BC
-        Ref B: DB3EDGE2220 Ref C: 2024-07-29T09:06:59Z'
+      - 'Ref SnR: 66a914be37cd42ada7010de81c968b91|Ref A: 49E77DFE69D0451F8EF5C7AF9C18C44D
+        Ref B: DB3EDGE2017 Ref C: 2024-07-30T16:28:46Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-dd2gk, mapsplatform-forwardgeocoder-service-69c675d4f5-ltvqp
+      - mapsplatform-frontend-5989d449fd-895xs, mapsplatform-forwardgeocoder-service-69c675d4f5-9fk55
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '70'
+      - '71'
       X-Azure-Ref:
-      - 20240729T090659Z-154b59dbc6d5lqv7gb5ha8t1mw00000003kg00000001cadv
+      - 20240730T162846Z-17cc7bff758vf2clbc4gk43ak800000006hg00000000ck8m
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -985,8 +1031,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:59 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:46 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Stockholm?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -1006,7 +1052,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:06:59 GMT
+      - Tue, 30 Jul 2024 16:28:47 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -1024,18 +1070,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 6d2cad6e336058231472669a7ed0b89e
+      - 2730035bae948248fa2a721c03ef4778
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75bb3f3cf452288aa0547c5af8a98|Ref A: FDD8C3589C0045C483238513F48BC402
-        Ref B: DB3EDGE2612 Ref C: 2024-07-29T09:06:59Z'
+      - 'Ref SnR: 66a914bf428c4399937fbff28336616d|Ref A: 7104830335AF49C8AA0E5BF014913552
+        Ref B: DB3EDGE2115 Ref C: 2024-07-30T16:28:47Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-4c4wh, mapsplatform-forwardgeocoder-service-69c675d4f5-65llh
+      - mapsplatform-frontend-5989d449fd-ldtnd, mapsplatform-forwardgeocoder-service-69c675d4f5-7z7j7
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '69'
+      - '177'
       X-Azure-Ref:
-      - 20240729T090659Z-17cc7bff758gfnzguth2k98dds00000005eg00000000495q
+      - 20240730T162846Z-154b59dbc6dsrvwcuf0s6c73vg00000008ag00000000gq99
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -1043,8 +1089,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:06:59 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:47 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Sweden?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -1064,7 +1110,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:07:00 GMT
+      - Tue, 30 Jul 2024 16:28:47 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -1082,18 +1128,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 910686f32519bd0e824618452d17a10f
+      - f3ba5b7febe5d3dcaee003afde3a7eee
       X-Msedge-Ref:
-      - 'Ref A: ADB61E47A1204F48AB2C651277974B83 Ref B: DB3EDGE2514 Ref C: 2024-07-29T09:07:00Z|Ref
-        SnR: 66a75bb4896c49209db7952771815bb0'
+      - 'Ref A: B4A13B1DE3D443FA8AA95F7CEED265EB Ref B: DB3EDGE2514 Ref C: 2024-07-30T16:28:47Z|Ref
+        SnR: 66a914bf4faa401daefe902234ca3549'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-p9f22, mapsplatform-forwardgeocoder-service-69c675d4f5-6d962
+      - mapsplatform-frontend-5989d449fd-zk7ph, mapsplatform-forwardgeocoder-service-69c675d4f5-6d962
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '309'
+      - '67'
       X-Azure-Ref:
-      - 20240729T090659Z-154b59dbc6d9w7951fxgptmsxn00000008mg00000000ykf3
+      - 20240730T162847Z-17cc7bff758ct7zf10wxst3b9g00000006q00000000017fn
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -1101,6 +1147,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:07:00 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:47 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_pinpointhq.yml b/spec/fixtures/cassettes/create_job_pinpointhq.yml
index 0fd26e4c..c135540f 100644
--- a/spec/fixtures/cassettes/create_job_pinpointhq.yml
+++ b/spec/fixtures/cassettes/create_job_pinpointhq.yml
@@ -21,7 +21,7 @@ http_interactions:
       Server:
       - nginx
       Date:
-      - Mon, 29 Jul 2024 09:07:00 GMT
+      - Tue, 30 Jul 2024 16:28:47 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -45,22 +45,22 @@ http_interactions:
       Content-Security-Policy-Report-Only:
       - 'default-src ''self'' https:; font-src ''self'' https: data:; img-src ''self''
         https: data:; object-src ''none''; media-src ''self'' https: blob:; script-src
-        ''self'' https: ''strict-dynamic'' ''nonce-6e77114cc02c46d700320eb255ac0cdd'';
+        ''self'' https: ''strict-dynamic'' ''nonce-140c1ac91ff481da4640348758e8e65a'';
         style-src ''self'' https: ''unsafe-inline''; connect-src ''self'' https: wss:;
         base-uri ''none''; report-uri /csp_violation_reports'
       Set-Cookie:
       - LSW_WEB=LSW_WEB2; path=/
-      - _pinpoint_session=rqF4adHt1flyhFxZ8aQdeziTMMp%2Bfr%2BJf%2FLJmHQqCOQFRX3JlooM2XFX%2FNKxUOf4ZZL4tmU5znweYSY3nyVCSY2Ouda%2FvIuFV7GpxILemeXea2bBmOL8uhyQS%2Bh5GJW9YjgdCtPF%2BUnXx9J8HxgAk7Ngrcfgq%2BRMGm3390yTH87rkMroPOTwSYjgpOvGCbkYcsrVKZSmT6jOnhxem535MSFpFJkYArWU1l2SlCjMBpVodcVENts2PbPfHfeC93TgTDGkoPcuK5w0g%2FXNhYSWZc%2FSnGYxWljRj14tJCM87vWzVmM%3D--BG%2Br9GZKYPS4fJvO--mTyZaZI%2B22qJd1yxW8i9Cg%3D%3D;
-        domain=.pinpointhq.com; path=/; expires=Mon, 05 Aug 2024 09:07:00 GMT; secure;
+      - _pinpoint_session=yhxLu%2BwLIPdS2VKJ%2BKPzY%2BeuPrZznl0aYMtjedc117UhqVZsmTYXmrzZP0%2BC1U%2BMvpEhfS2tPXegXVOYZx7Emsb99pqB%2FC3uDt43cWllMh6qLBquWBY%2F61DkTp9kiTdFWv97%2BEFQEIyjWU6%2FBbcw%2BVMkmYxDzuvFVy7CQJNFYE13AWFd7w7FjmKbUcEtPF%2BuxlAkVFpJDzfhg5v3%2FRPqEltDfPWeZ9%2FpFFJqauITc1SCl6D96o4lNBRiZcoyWzdIY%2Bb9ZjzqmibN8wimSzxPUA7szuu0eTv4rfq42eg4TO17wJ8%3D--2WRdkLSSqOgJFi1Z--rdwHk8oqA1Hn6X1kAj5C1w%3D%3D;
+        domain=.pinpointhq.com; path=/; expires=Tue, 06 Aug 2024 16:28:47 GMT; secure;
         HttpOnly; SameSite=None
-      - ahoy_visit=1e82c3ab-e7f1-4946-b71f-91838dffcd1b; path=/; expires=Mon, 29 Jul
-        2024 13:07:00 GMT; secure
-      - ahoy_visitor=deac08ca-9f34-4186-b521-e5c61824ae0e; path=/; expires=Wed, 29
-        Jul 2026 09:07:00 GMT; secure
+      - ahoy_visit=21209447-a9f2-489f-a672-c2a97f082ad7; path=/; expires=Tue, 30 Jul
+        2024 20:28:47 GMT; secure
+      - ahoy_visitor=6fd453dc-0570-4830-a50a-d3b3aa336495; path=/; expires=Thu, 30
+        Jul 2026 16:28:47 GMT; secure
       X-Request-Id:
-      - 3a6b6510-6d7d-4385-8582-92a5ce8121c1
+      - c71cfa46-0ff5-4917-8f84-fdee9c39235a
       X-Runtime:
-      - '0.191175'
+      - '0.229457'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Vary:
@@ -71,7 +71,7 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         {"data":[{"id":"194729","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eInterview Dates - Monday 16th \u0026amp; Tuesday 17th September 2024 \u003cbr\u003e\u003cbr\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003c/strong\u003e\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003e\u003cstrong\u003ea.carr2@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-26T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking an experienced Early Years, primary and/or secondary age phase practitioner to take on the role of teacher and tutor for the academic assignments of BSU’s highly regarded SCITT PGCE programme.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eTeaching takes place both in-person at our SCITTs across England and online, with much of the course delivered virtually.\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University’s School of Education provides the SCITT PGCE award to a growing number of SCITT providers, working with 13 partners from September 2024.\u0026nbsp; Whilst the SCITT provides the training that leads to a recommendation for QTS, this role relates to Bath Spa University’s provision of the academic award of PGCE. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn order to support trainees in understanding the value of critical awareness of professional practice at Masters level, through the completion of academic assignments, the post holder will deliver: SCITT assignment launches, seminars to groups of trainees, individual tutorials, online support and assignment assessment. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe work of the SCITT PGCE programme is delivered at a range of sites across England.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have QTS, a first degree, a higher degree (or working towards a higher degree) and will be confident in teaching at Masters level and working with trainee teachers.\u0026nbsp; Experience of working in a school or other educational institution is essential.\u0026nbsp; Experience in the Early Years, primary and/or secondary age phase is essential, but you will also have knowledge and understanding of learning pedagogy and current thinking in wider educational issues. \u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent communication skills, a collaborative and enthusiastic approach to teacher education and be a committed team player.\u0026nbsp; You will be a confident communicator and user of IT, particularly online learning environments.\u0026nbsp; You must be a flexible thinker and be willing to engage in the development of this area of teacher education.\u003cbr\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003ea.carr2@bathspa.ac.uk\u003c/a\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow for School-Centred Initial Teacher Training (SCITT) PGCE Programme","url":"https://bathspa.pinpointhq.com/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","path":"/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"213031","requisition_id":"282/23/24","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"196971","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 7 - £37,099 - £41,732 per annum\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eInterview Date - W/C 12th August\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-04T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eThis is an exciting opportunity to join us as Strategic Projects \u0026amp; Change Manager at Bath Spa University. You will be involved in a wide range of strategic activities and will play a key role in managing and facilitating change projects, new ways of working, and process improvements.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs Strategic Projects \u0026amp; Change Manager you will manage project initiation phases, oversee large-scale programs, and ensure effective end-to-end project management. \u003cbr\u003e\u003cbr\u003eYou will work closely with senior leadership, project sponsors, and teams to meet project requirements, timelines, and outputs, while maintaining robust communication channels. \u003cbr\u003e\u003cbr\u003eYour role will involve coordinating project activities, supporting senior oversight groups, tracking project metrics, and developing best practice project management collateral. \u003cbr\u003e\u003cbr\u003eAdditionally, you will facilitate forums for cross-university collaboration, build strong networks across academic and professional services teams, and contribute to staff development and your own professional growth.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent stakeholder management skills with a demonstrable ability to communicate effectively with a diverse audience will be key. \u003cbr\u003e\u003cbr\u003eYou will have a structured approach to producing accurate project documentation and reporting, be self-motivated, and experienced at working at a strategic level across a varied workload.\u003cbr\u003e\u003cbr\u003eIn addition, you will be flexible, calm under pressure and will have excellent organisational and prioritisation skills\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Strategic Projects \u0026 Change Manager","url":"https://bathspa.pinpointhq.com/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","path":"/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"215223","requisition_id":"348/23/24","department":{"id":"36037","name":"Strategic Projects and Change Unit"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"197279","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eFull Time Fixed Term Contract initially for 12 months, although can be shortened or lengthened based on the maternity leave\u003cbr\u003e\u003cbr\u003eInterview Date - 14th August 2024\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking to recruit Teaching Fellows in Psychology to join our dedicated and committed team in Psychology.\u003cbr\u003e\u003cbr\u003e(Please note that the role is initially for 12 months, although can be shortened or lengthened based on the maternity leave)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will be the key support to undergraduate teaching across our programmes within Psychology. You will design and deliver teaching content across a range of modules at Levels 4 to 6 in Psychology Programmes, with a particular focus on Forensic Psychology, as well as contributing to curriculum planning and development, and engaging in research or scholarly activity in Psychology.\u003cbr\u003e\u003cbr\u003eYou will undertake teaching within Psychology in the form of lectures, practical sessions, seminars, discussions groups and tutorials as appropriate, whilst supporting undergraduate students individually and online.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn addition, you will help mark assessments associated with the teaching and will attend assessment and examination meetings as required.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking a flexible and positive individual who will be able to teach a broad range of Psychology at all undergraduate levels, with a particular focus on Forensic Psychology (though all areas of expertise are welcome) and have a BPS-Accredited undergraduate degree.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will have experience of teaching all aspects of general Psychology, as well as prior experience of different teaching methods and/or experience of university level teaching. As an excellent communicator, you will work successfully as part of a small team, whilst showing the ability to manage your own time with limited supervision.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role is available on a job-share basis that would enable you to complete postgraduate studies (e.g., a PhD) alongside the role.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor informal enquiries about the role, please contact Prof Peter Hills; \u003c/strong\u003e\u003ca href=\"mailto:p.hills@bathspa.ac.uk\"\u003e\u003cstrong\u003ep.hills@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow in Psychology (Maternity Cover)","url":"https://bathspa.pinpointhq.com/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","path":"/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"215498","requisition_id":"344/23/24","department":{"id":"25480","name":"School of Sciences"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198167","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a part time role, 28 hours per week.\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 6 - £24,457 - £27,261 per annum, pro rata £32,332-£36,024\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eSome evening and weekend working during term time will be required.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£24,457 - £27,261 per annum, pro rata £32,332-£36,024 ","compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking an dedicated Technical Demonstrator (moving image)\u003cstrong\u003e \u003c/strong\u003eto be responsible for the delivery of specialist technical skills demonstrations to either groups of students or one-to-one support to individuals here at Bath Spa University\u003cbr\u003e(This is a part time role, 28 hours per week)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"part_time","employment_type_text":"Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role of a Technical Demonstrator combines technical knowledge and innovative thinking with the design and delivery of hardware and software demonstrations to students. Within the role you will be responsible for ensuring the maintenance of specialist equipment is carried out within own area of work and that health and safety standards are complied with. This role will be based around the delivery of training and demonstration of moving image capture, motion graphics generation, editing and gallery presentation. It will be located at the Locksbrook Rd campus mainly working with students enrolled on courses within the Schools of Art, Film and Media and the School of Design.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eAs Technical Demonstrator you will demonstrate complex technical techniques to students from various programs, support individual and group student work, and develop and run workshops on the use of our facilities. You will be responsible for preparing resources and equipment, supervising students' project work, and ensuring health and safety compliance within the workspace. Additionally, you will conduct risk assessments, maintain equipment, and stay updated with new technologies and contemporary practices in your field. You may also advise on future resource requirements and supervise a small team of technical staff.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be a qualified Workshop and Laboratory Technician with an NVQ4, NEBSS, or degree in a relevant practical subject, or significant professional experience in a specialist area. You will have experience in demonstration or training, supervisory skills, and expertise in video capture, motion graphics, animation, and gallery presentation of moving images.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou should demonstrate a proactive approach to maintenance, development, and safety, possess excellent interpersonal, written, and oral communication skills, and have strong ICT capabilities.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe role requires the ability to plan and organise work, manage resources, liaise with staff, departments, and external agencies, use initiative and problem-solving skills, make decisions, and work under pressure to tight deadlines. Flexibility, adaptability, and a positive approach to change are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Technical Demonstrator (Moving Image)","url":"https://bathspa.pinpointhq.com/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","path":"/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"216378","requisition_id":"347/23/24","department":{"id":"30746","name":"Technical Services"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"198471","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the Games Development and Creative Computing (Games) courses at Bath Spa University.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of games design and development.\u0026nbsp;\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institution in games development or similar Creative Computing subjects. We expect that as a games and creative technology specialist, you will be actively engaged in related practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will ideally have additional industry and/or teaching experience using modern game engines such Unity3D and Unreal, and some knowledge of others. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience in a game production role is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer – Games Development","url":"https://bathspa.pinpointhq.com/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","path":"/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216674","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198483","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the BSc (HONS) Computing course at Bath Spa University. \u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of Computing.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institute in Computing subjects. We expect that as a Computing specialist, you will be actively engaged in computing practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have industry and/or teaching experience within one or more of the following areas: OO software development using C++, software engineering, and business analysis. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience developing creative and entertainment software is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer - Computing","url":"https://bathspa.pinpointhq.com/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","path":"/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216686","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198822","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eWe encourage applications from disabled people and can provide reasonable adjustments, so please let us know if there is anything we can do to make applying for this role more accessible for you. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eSalary: Grade 5 - £27,979 to £31,396 (per annum), £5,595.80 to £6,279.20 (pro-rata)\u003cbr\u003e\u003cbr\u003eThis is a 0.2 FTE part-time, one year fixed-term role.\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£27,979 - £31,396 / year","compensation_minimum":27979.0,"compensation_maximum":31396.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently\u003cstrong\u003e \u003c/strong\u003eseeking to appoint a Research Assistant to support the creation and development of a disability hub which aims to bring together and disseminate We Are The People research to the South West. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe Are The People (WATP) is a small research team of disabled academics and non-disabled allies engaged in disability research and disability activism. We've been awarded a five-year, £1million grant from the \u003ca href=\"https://wellcome.org/\"\u003e\u003cstrong\u003eWellcome Trust\u003c/strong\u003e\u003c/a\u003e to explore issues which affect disabled people in South West England.\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_part_time","employment_type_text":"Fixed Term - Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role involves developing an understanding of ongoing research by Disabled People’s Organisations (DPOs), creating a disability training programme led by disabled individuals, and organizing events to showcase findings. You will ensure the accessible dissemination of research results, investigate collaborative opportunities with DPOs, and build relationships with community contacts for future funding.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eKey responsibilities include providing guidance to community partners, contributing to meetings, adhering to Health and Safety guidelines, and developing research methods within the programme framework.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be passionate about disability equality and hold a good first degree in a relevant discipline such as Disability Studies, Psychology, Social Science, Arts, etc. You will also have demonstrable experience of working in a co-productive way with project partners, contributing to a community, charity or research environment.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will also show a demonstrable understanding of the sensitivities of working with underrepresented groups, and to respond to potential barriers in a compassionate way. In addition, you will be an excellent problem solver, flexible, adaptable and a committed team player. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact the team at: \u003ca href=\"mailto:WeAreThePeople@bathspa.ac.uk\"\u003eWeAreThePeople@bathspa.ac.uk\u003c/a\u003e \u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Research Assistant - We Are The People project","url":"https://bathspa.pinpointhq.com/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","path":"/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217032","requisition_id":"360_23_24  ","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199360","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis role is a one year fixed-term contact.\u003cbr\u003e\u003cbr\u003eSalary: Grade 8s, £42,978 to £44,263\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £44,263 / year","compensation_minimum":42978.0,"compensation_maximum":44263.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-11T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University is seeking a dynamic and innovative Head of Recruitment to lead and deliver cutting-edge resourcing solutions.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role focuses on developing sustainable staff recruitment strategies, optimizing our employer value proposition (EVP), and enhancing our recruitment branding across all platforms. (This is a 1 year Fixed Term Contract)\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will oversee a smooth and efficient recruitment process, enhancing both the candidate and hiring manager experience and will lead the recruitment team, providing expert guidance and support. Collaborating with senior managers, you will understand strategic recruitment needs and determine the best resourcing strategies. Proactive sourcing of hard-to-fill or senior roles through headhunting, microsites, and video content will be essential.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eSetting and reviewing key performance indicators (KPIs) will be a critical part of the role, ensuring effective recruitment processes and annual reporting on trends. You will embed our EVP through recruitment marketing techniques aligned with the University's values and culture and will build BSU’s presence on social media to increase engagement. Implementing initiatives to improve workforce diversity and ensuring recruitment efforts align with the University’s Equality, Diversity, and Inclusion (ED\u0026amp;I) Strategy is vital. Inclusive recruitment practices must be maintained throughout the candidate journey, and you will influence line managers to prioritise talent diversity.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eEstablishing and managing a talent pool process for future vacancies will be part of your remit, as well as building external networks to stay updated on recruitment trends and advising the University accordingly.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have proven expertise in employee resourcing strategies and recruitment processes, strong leadership and team management skills, and experience in developing and implementing EVP.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eProficiency in utilising social media for recruitment, a commitment to diversity and inclusion in the workplace, and excellent communication and relationship-building skills are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Head of Recruitment","url":"https://bathspa.pinpointhq.com/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","path":"/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217566","requisition_id":"254-23-24","department":{"id":"19087","name":"HR"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199810","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eTemporary, fixed term Semester/Trimester one and two 2024 -2025. Part Time Hours to be agreed.\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eGeneral teaching commences week beginning 30th September 2024 but module development will before these date. Our 2024/5 term dates can be found at https://www.bathspa.ac.uk/about-us/term-dates/\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are looking for talented Associate Lecturers in Law to join our collegial team, contributing to teaching and development of law modules on a part time basis at various times through the 2024/2025 academic year.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Associate Lecturer posts require lecturing, taking seminar groups, assessment and working as part of a team of tutors.\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAt Bath Spa University we work with one clear vision: to be a leading university in creativity, culture and enterprise. And we place collaboration at the heart of everything we do. With ever growing student numbers, we make sure our people are engaged and empowered by blending digital technologies, international perspectives, work-oriented connections and inspirational teaching. Together we’re on a journey to transform our students’ lives. And it starts with people like you.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eAbout Bath Business School\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eBath Business School is set within a beautiful countryside location, close to the world heritage city of Bath. Our staff and students are ethically aware, socially engaged and globally connected through our links to research, and professional and creative industry networks.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eOur Law Degree\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eOur new LLB Law degree has been designed to be unique and incorporates a range of business skills and optional modules whilst encompassing the foundations of legal knowledge found in SQE 1 and many elements of SQE 2.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Bath Spa LLB is at the cutting edge of legal education. Our LLB offers a range of authentic assessments, the offer of multiple placement opportunities including a placement year, as well as the opportunity of undertaking the Law Clinic module for final year students.\u0026nbsp; Our Law Clinic is a result of an impressive joint venture between Bath Spa University, Stone King LLP and the Citizens Advice Bureau BANES.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe believe in giving our students a high-quality educational experience, exceptional opportunities to become highly employable as well as unrivalled pastoral care.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor further information contact Steven Goulton, Law Course Director, Bath Business School, \u003c/strong\u003e\u003ca href=\"mailto:s.goulton@bathspa.ac.uk\"\u003e\u003cstrong\u003es.goulton@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","key_responsibilities_header":"About Us.","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eIdeally you will have expertise in one or more of the following areas (please see below for further information on Associate Lecturer role specifics):\u003c/div\u003e\u003cul\u003e\u003cli\u003e\u003c!--block--\u003eTort Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmployment Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eBusiness Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eDissertation supervision\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEquity and trusts\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eProperty Law\u0026nbsp;\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmerging technologies – AI, cyberlaw etc\u003c/li\u003e\u003c/ul\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer in Law","url":"https://bathspa.pinpointhq.com/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","path":"/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218013","requisition_id":"","department":{"id":"19085","name":"Business School"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199873","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - 11th \u0026amp; 12th September 2024\u003cbr\u003e\u003cbr\u003ePlease email Clara Giaminardi \u003c/strong\u003e\u003ca href=\"mailto:c.giaminardi@bathspa.ac.uk\"\u003e\u003cstrong\u003ec.giaminardi@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e directly for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eOur BA (Hons) Fashion Photography course is looking for associate lecturers with in-depth knowledge and/or industry experience in the areas of fashion photography, fashion styling and fashion communication to deliver teaching on our level 4 and level 5 modules.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs an associate lecturer on BA (Hons) Fasion Photography, your primary responsibility will be delivering engaging and high quality teaching in the appropriate subject area. This includes developing and undertaking in-person lectures, practical workshops, seminars and tutorials to support our level 4 and level 5 students in the development of their work.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eIn the role, you will also be marking and assessing module work, providing constructive feedback and attending assessment meetings where required to ensure fair and consistent grading. You will also be expected to work closely with module staff and support on some administrative tasks, ensuring the smooth running of the module. This includes engaging with existing virtual learning environments to ensure cohesive dissemination of module materials and student communication across the course.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eThe role requires an in-depth subject knowledge and/or industry expertise in the areas of fashion photography, fashion styling and/or fashion communication. You will have excellent communication and interpersonal skills and will be able to translate key skills and concepts into appropriate language and tasks for level 4 and level 5 students. A solid understanding of contemporary trends and industry practices is essential to ensure high quality of teaching for students going into future industry.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003ePrior experience teaching undergraduate students in these areas is desirable. You will have excellent organisational and time management skills, and be able to work successfully as part of a small team. Alongside solid IT skills, expertise in industry specific digital tools such as the Adobe Creative Suite is beneficial.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer, BA (Hons) Fashion Photography","url":"https://bathspa.pinpointhq.com/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","path":"/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218077","requisition_id":"","department":{"id":"36272","name":"School of Art, Film \u0026 Media"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"200623","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a Fixed Term Contract until November 2024.\u003cbr\u003e\u003cbr\u003eSalary: Grade 2, £23,152\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u003c/strong\u003e\u003cbr\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£23,152 / year","compensation_minimum":23152.0,"compensation_maximum":23152.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-05T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eExciting opportunity for a reliable and dedicated individual to join our elite Facilities and Services team in helping maintain a clean and safe environment on our Sion Hill Campus. (This is a Fixed Term Contract until November 2024)\u003cbr\u003e\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eOur team prides ourselves on our positive ‘can do’ approach towards supporting our students, staff and visitors.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eAs a valued member of our vibrant team, you'll be the unsung hero behind the scenes, transforming every corner of our campus into a sparkling haven of knowledge and innovation at the same time as providing excellent customer service.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eEmbrace the excitement of a dynamic environment where no two days are alike.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eDue to the University’s locations, having your own transport is recommended, however, there is the option of public transport (this is limited during the summer months).\u003cbr\u003e\u0026nbsp;\u003cbr\u003eCleaning experience is beneficial but what we’re looking for most is reliability, attention to detail and a willingness to learn.\u003cbr\u003e\u0026nbsp;\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Full Time Cleaner (Fixed Term Contract)","url":"https://bathspa.pinpointhq.com/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","path":"/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218783","requisition_id":"","department":{"id":"25473","name":"Estates"},"division":null,"structure_custom_group_one":null},"location":{"id":"14960","city":"Bath","name":"Bath - Sion Hill Campus","province":"Bath"}}]}
-  recorded_at: Mon, 29 Jul 2024 09:07:00 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:47 GMT
 - request:
     method: get
     uri: https://bathspa.pinpointhq.com/
@@ -93,7 +93,7 @@ http_interactions:
       Server:
       - nginx
       Date:
-      - Mon, 29 Jul 2024 09:07:00 GMT
+      - Tue, 30 Jul 2024 16:28:48 GMT
       Content-Type:
       - text/html; charset=utf-8
       Transfer-Encoding:
@@ -111,28 +111,28 @@ http_interactions:
       Referrer-Policy:
       - strict-origin-when-cross-origin
       Etag:
-      - W/"e249188507b3fbf6ab05b0c45d4c3649"
+      - W/"020e8e7a45a052b70a07652d0d5b2837"
       Cache-Control:
       - max-age=0, private, must-revalidate
       Content-Security-Policy-Report-Only:
       - 'default-src ''self'' https:; font-src ''self'' https: data:; img-src ''self''
         https: data:; object-src ''none''; media-src ''self'' https: blob:; script-src
-        ''self'' https: ''strict-dynamic'' ''nonce-d0ec80cf883a87fd072ede6364f7fdd8'';
+        ''self'' https: ''strict-dynamic'' ''nonce-5b08b3e58a1af308e956005a8a13b467'';
         style-src ''self'' https: ''unsafe-inline''; connect-src ''self'' https: wss:;
         base-uri ''none''; report-uri /csp_violation_reports'
       Set-Cookie:
-      - LSW_WEB=LSW_WEB7; path=/
-      - _pinpoint_session=CMOZ4%2Fn9dH878Dzn07awLAzFlXD4IgI0HCrigJQP7q6KUU8hAIxf%2BqXFqjl2eeLaq2U4MduqeFor88Pd4t1xGeMMASg4hnimUB3gNN9VHry89UO%2BLLrxodVGT8mn8z7RTYPti9lbXgttJ2EZyfu7nZ120IeaIF6xkFiFNW8ySO8UTiz0laG5wsDxWdN1EVyuXJvBcfeJZzwBKXnggVXBS4QAedameV%2F8DbXOyC9W%2FzEnuxNBgbCVJBYxtbOyxjiATeeCEgb8B8Ds8g%2Bye0NMcuW8XCLyW6%2B1D5%2FBzjdH%2FNdv0s0F4xK7HUtlVeyjz2%2FzBJfcq0VL%2B7300mrY0BdgzsT0a30CCht4LT5%2FpuFeetCsdvamo8%2FgnBFNPX3N1VgmcOA%2FXOJIf2WoAMkMlqbYjVAEng%3D%3D--IuWW7tY5%2Fb6z055%2B--hDIaOPPo09k5UOxy2Ud80w%3D%3D;
-        domain=.pinpointhq.com; path=/; expires=Mon, 05 Aug 2024 09:07:00 GMT; secure;
+      - LSW_WEB=LSW_WEB5; path=/
+      - _pinpoint_session=XEBBgRLOBZDLADJ6%2B4%2FS9diwZTXWUPrjU6efoomqXepbDle93KQ2XMKJ6l8eA%2BhLavtqve88yX1FrDlclGDuntZRA3Y8e%2FKIcf%2Fiw%2B%2FHQU0srK4cEZ809mbcYvvEPQdy16MYnDAnJNIhigrxAm5MGzur6RrdkHFPTFKS4v%2FmIz5llnYctBZIImRgDebqrzrbVvb7xh5K7n7yeUdfFfsqLCxwBfdqr72g6SPJnMQqooUN7FmRmXX%2FBd8NfDZGst%2BFrxDyHplz75HVeu44%2Btv2vnEvus7B1%2FATHxHUPHKVVel9YThXLC4DL7JBNZFo14fF8%2BxA6bHGIHEOny%2FsC%2FILEGPXV48G7fnP0I4sfW6ooxLrkGDr6KLVF5Rmk2l7fakJEIdT48P%2BUzh3NMDkAGDKlb8CEw%3D%3D--%2BVskcyuOA9FOQQAc--QiYEAYUy9PdVPhjhxtxGwg%3D%3D;
+        domain=.pinpointhq.com; path=/; expires=Tue, 06 Aug 2024 16:28:48 GMT; secure;
         HttpOnly; SameSite=None
-      - ahoy_visit=2c471022-b13b-4998-8afd-21abe0c650ed; path=/; expires=Mon, 29 Jul
-        2024 13:07:00 GMT; secure
-      - ahoy_visitor=79658c95-6c04-4aa1-a50f-eeaa38b29efb; path=/; expires=Wed, 29
-        Jul 2026 09:07:00 GMT; secure
+      - ahoy_visit=8ab99134-e8bd-41a6-9a25-9d44b5a98d44; path=/; expires=Tue, 30 Jul
+        2024 20:28:47 GMT; secure
+      - ahoy_visitor=99edbcf9-2ba7-411d-9725-d3505274280d; path=/; expires=Thu, 30
+        Jul 2026 16:28:47 GMT; secure
       X-Request-Id:
-      - 97567282-bc64-47a5-81d3-d3d54e4635a4
+      - 4ea9db2d-c244-409d-b8a4-523e40f863de
       X-Runtime:
-      - '0.354762'
+      - '0.260497'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       X-Powered-By:
@@ -140,8 +140,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        <!DOCTYPE html>
<html lang="en-GB">
<head>
<script nonce="d0ec80cf883a87fd072ede6364f7fdd8">var _rollbarConfig = {"accessToken":"0ab41f8274e04d638238b61af91c297a","captureUncaught":true,"payload":{"environment":"production"},"ignoredMessages":["SP401 - Unauthorized"],"checkIgnore":function(isUncaught, args, payload) {
  var message = args[0];
  var ignoredMobileMessages = [
    `Uncaught SyntaxError: Unexpected token ';'`,
    `SyntaxError: Unexpected token ';'. Expected ')' to end a compound expression.`
  ];
  var userAgentContainsMobile = window && window.navigator && window.navigator.userAgent && window.navigator.userAgent.indexOf('Mobile') !== -1;
  if(userAgentContainsMobile && ignoredMobileMessages.includes(message)) {
    // ignore this message
    return true;
  }
  var ignoredMessages = [
    `ResizeObserver loop completed with undelivered notifications.`,
    `Script error.`
  ];
  if(ignoredMessages.includes(message)) {
    // ignore this message
    return true;
  }
}
};</script>
<script nonce="d0ec80cf883a87fd072ede6364f7fdd8">!function(r){var e={};function o(n){if(e[n])return e[n].exports;var t=e[n]={i:n,l:!1,exports:{}};return r[n].call(t.exports,t,t.exports,o),t.l=!0,t.exports}o.m=r,o.c=e,o.d=function(r,e,n){o.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},o.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},o.t=function(r,e){if(1&e&&(r=o(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var t in r)o.d(n,t,function(e){return r[e]}.bind(null,t));return n},o.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return o.d(e,"a",e),e},o.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},o.p="",o(o.s=0)}([function(r,e,o){"use strict";var n=o(1),t=o(5);_rollbarConfig=_rollbarConfig||{},_rollbarConfig.rollbarJsUrl=_rollbarConfig.rollbarJsUrl||"https://cdn.rollbar.com/rollbarjs/refs/tags/v2.26.1/rollbar.min.js",_rollbarConfig.async=void 0===_rollbarConfig.async||_rollbarConfig.async;var a=n.setupShim(window,_rollbarConfig),l=t(_rollbarConfig);window.rollbar=n.Rollbar,a.loadFull(window,document,!_rollbarConfig.async,_rollbarConfig,l)},function(r,e,o){"use strict";var n=o(2),t=o(3);function a(r){return function(){try{return r.apply(this,arguments)}catch(r){try{console.error("[Rollbar]: Internal error",r)}catch(r){}}}}var l=0;function i(r,e){this.options=r,this._rollbarOldOnError=null;var o=l++;this.shimId=function(){return o},"undefined"!=typeof window&&window._rollbarShims&&(window._rollbarShims[o]={handler:e,messages:[]})}var s=o(4),d=function(r,e){return new i(r,e)},c=function(r){return new s(d,r)};function u(r){return a((function(){var e=this,o=Array.prototype.slice.call(arguments,0),n={shim:e,method:r,args:o,ts:new Date};window._rollbarShims[this.shimId()].messages.push(n)}))}i.prototype.loadFull=function(r,e,o,n,t){var l=!1,i=e.createElement("script"),s=e.getElementsByTagName("script")[0],d=s.parentNode;i.crossOrigin="",i.src=n.rollbarJsUrl,o||(i.async=!0),i.onload=i.onreadystatechange=a((function(){if(!(l||this.readyState&&"loaded"!==this.readyState&&"complete"!==this.readyState)){i.onload=i.onreadystatechange=null;try{d.removeChild(i)}catch(r){}l=!0,function(){var e;if(void 0===r._rollbarDidLoad){e=new Error("rollbar.js did not load");for(var o,n,a,l,i=0;o=r._rollbarShims[i++];)for(o=o.messages||[];n=o.shift();)for(a=n.args||[],i=0;i<a.length;++i)if("function"==typeof(l=a[i])){l(e);break}}"function"==typeof t&&t(e)}()}})),d.insertBefore(i,s)},i.prototype.wrap=function(r,e,o){try{var n;if(n="function"==typeof e?e:function(){return e||{}},"function"!=typeof r)return r;if(r._isWrap)return r;if(!r._rollbar_wrapped&&(r._rollbar_wrapped=function(){o&&"function"==typeof o&&o.apply(this,arguments);try{return r.apply(this,arguments)}catch(o){var e=o;throw e&&("string"==typeof e&&(e=new String(e)),e._rollbarContext=n()||{},e._rollbarContext._wrappedSource=r.toString(),window._rollbarWrappedError=e),e}},r._rollbar_wrapped._isWrap=!0,r.hasOwnProperty))for(var t in r)r.hasOwnProperty(t)&&(r._rollbar_wrapped[t]=r[t]);return r._rollbar_wrapped}catch(e){return r}};for(var p="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,captureEvent,captureDomContentLoaded,captureLoad".split(","),f=0;f<p.length;++f)i.prototype[p[f]]=u(p[f]);r.exports={setupShim:function(r,e){if(r){var o=e.globalAlias||"Rollbar";if("object"==typeof r[o])return r[o];r._rollbarShims={},r._rollbarWrappedError=null;var l=new c(e);return a((function(){e.captureUncaught&&(l._rollbarOldOnError=r.onerror,n.captureUncaughtExceptions(r,l,!0),e.wrapGlobalEventHandlers&&t(r,l,!0)),e.captureUnhandledRejections&&n.captureUnhandledRejections(r,l,!0);var a=e.autoInstrument;return!1!==e.enabled&&(void 0===a||!0===a||function(r){return!("object"!=typeof r||void 0!==r.page&&!r.page)}(a))&&r.addEventListener&&(r.addEventListener("load",l.captureLoad.bind(l)),r.addEventListener("DOMContentLoaded",l.captureDomContentLoaded.bind(l))),r[o]=l,l}))()}},Rollbar:c}},function(r,e,o){"use strict";function n(r,e,o,n){r._rollbarWrappedError&&(n[4]||(n[4]=r._rollbarWrappedError),n[5]||(n[5]=r._rollbarWrappedError._rollbarContext),r._rollbarWrappedError=null);var t=e.handleUncaughtException.apply(e,n);o&&o.apply(r,n),"anonymous"===t&&(e.anonymousErrorsPending+=1)}r.exports={captureUncaughtExceptions:function(r,e,o){if(r){var t;if("function"==typeof e._rollbarOldOnError)t=e._rollbarOldOnError;else if(r.onerror){for(t=r.onerror;t._rollbarOldOnError;)t=t._rollbarOldOnError;e._rollbarOldOnError=t}e.handleAnonymousErrors();var a=function(){var o=Array.prototype.slice.call(arguments,0);n(r,e,t,o)};o&&(a._rollbarOldOnError=t),r.onerror=a}},captureUnhandledRejections:function(r,e,o){if(r){"function"==typeof r._rollbarURH&&r._rollbarURH.belongsToShim&&r.removeEventListener("unhandledrejection",r._rollbarURH);var n=function(r){var o,n,t;try{o=r.reason}catch(r){o=void 0}try{n=r.promise}catch(r){n="[unhandledrejection] error getting `promise` from event"}try{t=r.detail,!o&&t&&(o=t.reason,n=t.promise)}catch(r){}o||(o="[unhandledrejection] error getting `reason` from event"),e&&e.handleUnhandledRejection&&e.handleUnhandledRejection(o,n)};n.belongsToShim=o,r._rollbarURH=n,r.addEventListener("unhandledrejection",n)}}}},function(r,e,o){"use strict";function n(r,e,o){if(e.hasOwnProperty&&e.hasOwnProperty("addEventListener")){for(var n=e.addEventListener;n._rollbarOldAdd&&n.belongsToShim;)n=n._rollbarOldAdd;var t=function(e,o,t){n.call(this,e,r.wrap(o),t)};t._rollbarOldAdd=n,t.belongsToShim=o,e.addEventListener=t;for(var a=e.removeEventListener;a._rollbarOldRemove&&a.belongsToShim;)a=a._rollbarOldRemove;var l=function(r,e,o){a.call(this,r,e&&e._rollbar_wrapped||e,o)};l._rollbarOldRemove=a,l.belongsToShim=o,e.removeEventListener=l}}r.exports=function(r,e,o){if(r){var t,a,l="EventTarget,Window,Node,ApplicationCache,AudioTrackList,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");for(t=0;t<l.length;++t)r[a=l[t]]&&r[a].prototype&&n(e,r[a].prototype,o)}}},function(r,e,o){"use strict";function n(r,e){this.impl=r(e,this),this.options=e,function(r){for(var e=function(r){return function(){var e=Array.prototype.slice.call(arguments,0);if(this.impl[r])return this.impl[r].apply(this.impl,e)}},o="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,_createItem,wrap,loadFull,shimId,captureEvent,captureDomContentLoaded,captureLoad".split(","),n=0;n<o.length;n++)r[o[n]]=e(o[n])}(n.prototype)}n.prototype._swapAndProcessMessages=function(r,e){var o,n,t;for(this.impl=r(this.options);o=e.shift();)n=o.method,t=o.args,this[n]&&"function"==typeof this[n]&&("captureDomContentLoaded"===n||"captureLoad"===n?this[n].apply(this,[t[0],o.ts]):this[n].apply(this,t));return this},r.exports=n},function(r,e,o){"use strict";r.exports=function(r){return function(e){if(!e&&!window._rollbarInitialized){for(var o,n,t=(r=r||{}).globalAlias||"Rollbar",a=window.rollbar,l=function(r){return new a(r)},i=0;o=window._rollbarShims[i++];)n||(n=o.handler),o.handler._swapAndProcessMessages(l,o.messages);window[t]=n,window._rollbarInitialized=!0}}}}]);</script>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  
  <title>Jobs at Bath Spa University | Bath Spa University Careers</title>
  <meta name="description" content="Learn more about working at Bath Spa University and discover our latest career opportunities">

  <style>
    :root {
      --theme-primary-color: #455C51;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #ED9D85;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <script nonce="d0ec80cf883a87fd072ede6364f7fdd8">
//<![CDATA[

    window.essentialCookiesOnly = false;

    window.legacyCookieData = {"href":"/cookie-policy","message":"We use cookies to ensure you get the best experience on our website.","dismiss":"Got it!","link":"Learn more"};

    window.cookieConsentData = {"customContent":{"notice":"We use cookies to ensure you get the best experience on our website.","explanation":"We use cookies to ensure the basic functionalities of the website and to enhance your online experience. You can choose for each category to opt-in/out whenever you want. For more details relative to cookies and other sensitive data, please read the full <a href='/cookie-policy'>privacy policy</a>.","further_information":null},"translations":{"accept_all":"Accept all","close":"Close","cookie_preferences":"Cookie preferences","cookies":"Cookies","description":"Description","domain":"Domain","expiration":"Expiration","more_information":"More information","name":"Name","reject_all":"Reject all","save_settings":"Save settings","settings":"Settings","strictly_necessary_cookies":"Strictly necessary cookies","these_cookies_are_essential":"These cookies are essential for the proper functioning of our website. Without these cookies, the website may not work properly.","as_soon_as_browser_window_is_closed":"As soon as browser window is closed","allows_us_to_associate_file_uploads":"Allows us to associate file uploads to our file storage provider with your form submissions","allows_our_load_balancer":"Allows our load balancer to send your specific traffic to the same backend server","saves_your_decisions":"Saves your decisions about these cookies so we don't need to ask every time","analytics_and_performance_cookies":"Analytics and Performance cookies","these_cookies_remember_the_choices":"These cookies allow the website to remember the choices you have made in the past","internal_metrics_collector":"We use an internal metrics collector to understand interactions with our website over time","six_months":"Six months","two_years":"Two years","four_hours":"Four hours"}};

//]]>
</script>
  <script src="https://d2n5ied94mazop.cloudfront.net/packs/js/runtime-4ee0bc422406a939a04f.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/8860-54ebbc9015ed0678f9b4.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/application-7fc02963bbe1c1231110.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/7758-500534d14de13d6d913d.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/4934-7ef1df48c38cb8a32707.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cloudinary-4e5eb5d8dc0e193d4cef.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cookieconsent-76ba7ccf84597c35e667.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cdp-84feff2ddc8a9978561d.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/gtm-data-layer-9c7afd0f3a5aa7c9719c.js" data-turbolinks-track="reload" nonce="d0ec80cf883a87fd072ede6364f7fdd8" defer="defer"></script>
  <link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/application-79f60752.css" data-turbolinks-track="reload" />
<link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/cookieconsent-4c4dfb09.css" data-turbolinks-track="reload" />

  <meta name="turbolinks-cache-control" content="no-preview">

  <meta name="csrf-param" content="authenticity_token" />
<meta name="csrf-token" content="G/cvJHQ/sH44xe5fhBs66yxL2nYMEz7jT0tk4SKlavu1HLcpjt+7reJDAXfYzO7NlSlxfG/9kEBWVYCgeWHx+A==" />
  <meta name="csp-nonce" content="d0ec80cf883a87fd072ede6364f7fdd8" />

  <link rel="shortcut icon" type="image/x-icon" href="https://res.cloudinary.com/pinpointhq/image/upload/c_fill,f_auto,h_32,q_auto,w_32/v1/uploads/production/lyby5aqq3zkcbluwtwgv.png" />

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <script src="https://kit.fontawesome.com/832bb86d52.js" crossorigin="anonymous" nonce="d0ec80cf883a87fd072ede6364f7fdd8"></script>

  

    <link rel="alternate" type="application/rss+xml" title="RSS" href="https://bathspa.pinpointhq.com/jobs.rss" />


  
    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;600;700&amp;display=swap" rel="stylesheet">
    <style>
      body,
      input {
        font-family: Montserrat, "GTWalsheimPro", "Helvetica Neue", "Helvetica", sans-serif !important;
      }
    </style>


  
    <style type="text/css">
      /* (Default Options) Custom Type to allow us to use both of our brand typefaces in heros etc */
.pinpoint-block--hero .careers-hero-block__title {
font-weight: 700;
}
.pinpoint-block--text .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
margin-bottom: 20px;
}
.pinpoint-block--text .careers-block__trix {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--cards .careers-card-block__h3 {
font-weight: 700;
line-height: 1.2;
}
.pinpoint-block--cards .careers-card-block__p {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--jobs .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
}

/* (Default Options) Custom Footer */
.external-footer {
padding: 32px;
}

/* (Default Options) Testimonial Block */
.pinpoint-block--testimonial img {
border-radius: 185px;
}
.pinpoint-block--testimonial cite {
font-weight: 700 !important;
letter-spacing: 3px;
}
.pinpoint-block--testimonial .careers-testimonial-block {
align-items: center;
}

/* (Default Options) External Panels - e.g. titles on JDs, Interview Scheduling, etc.) */
.external-panel .external-panel__title {
font-weight: 700;
}

/* (Default Options) Custom Hero Image Positioning */
.careers-hero-block--image {
background-position: center;
}

/* (Default Options) Hide the Logo Text */
.careers-navigation-block__logo-text,
.careers-hero-block__logo-text {
display: none;
}

/* (Default Options) Make hero bigger because people like to see video and pictures */
.careers-hero-block-container {
padding-top: 80px !important;
padding-bottom: 80px !important;
}

/* --------------------------- AS ----------------------------- */

/* Customize navbar */
.pinpoint-block--navigation {
  padding-top: 5px;
  padding-bottom: 5px;
  background-color: #ffffff;
}

/* Set logo width */
@media (min-width: 768px) {
  .pinpoint-block--navigation img,
  .careers-hero-block--align-center img {
    width: 60px !important;
    height: auto !important;
  }
}

/* Customize nav items */
.careers-navigation-block__menu-item {
  color: #6D6D6D !important;
  background-color: transparent !important;
  text-transform: uppercase;
}

.careers-navigation-block__sub-nav-menu {
  color: #6D6D6D !important;
  background-color: #ffffff !important;
}

.careers-navigation-block__menu-section--center > div > div > .careers-navigation-block__menu-item > div {
  box-shadow: 0px 0px 10px -4px rgb(0 0 0 / 45%);
  overflow: hidden;
}

.careers-navigation-block__menu-item:hover,
.careers-navigation-block__sub-nav-menu:hover {
  color: #007EAC !important;
}

/* Update some of the styles to meet accessibility requirements */
.external-definition-list dt {
  color: #0078A3;
}

#js-careers-jobs-block,
.external-definition-list dd,
.external-definition-list dd 
.link--default,
.text-brand-ash-grey{
  color: #5c5c5c !important;
}

.external-button:focus, 
.external-button:active,
.link:focus,
.search__input:focus,
.filter .filter__button:focus {
  outline: 2px solid #2a8853 !important;
}

.external-button--theme-highlight:hover {
  background-color: #004f66;
}

.slick-dots li button:hover, .slick-dots li button:focus {
  outline: 1px solid #2a8853 !important;
}

/* Fix the placeholder colors */
input::placeholder,
.checkable-input__label,
.react-select .react-select__placeholder {
  color: #6F6F6F !important;
  opacity: 1;
}
    </style>


    




  

  <meta property="og:url" content="https://bathspa.pinpointhq.com/">
<meta property="og:type" content="website">
<meta property="og:locale" content="en_GB">
<meta property="og:title" content="Careers at Bath Spa University">
<meta property="og:description" content="Bath Spa University is where creative minds meet. Offering a wide range of courses across the arts, sciences, education, social science and business to over 7,500 students, the University employs outstanding creative professionals which support its aim to be a leading educational institution...">
<meta property="og:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@pinpointhq">
<meta name="twitter:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">

  <script nonce="d0ec80cf883a87fd072ede6364f7fdd8">
//<![CDATA[

    window.railsEnv = "production";

//]]>
</script>
  

    <link href="https://bathspa.pinpointhq.com/" rel="canonical" />
</head>

<body dir='auto' class="external-body pinpoint-page pinpoint-page--home theme-default">

  

  
  <style>
    :root {
      --theme-primary-color: #007eac;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #0078a3;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <style>
    @media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {
      .theme-primary-color-ie-override {
        color: #007eac !important;
      }
      .theme-primary-background-color-ie-override {
        background-color: #007eac !important;
      }
      .theme-primary-border-color-ie-override {
        border-color: #007eac !important;
      }
      .theme-secondary-color-ie-override {
        color: #F4F4F4 !important;
      }
      .theme-secondary-background-color-ie-override {
        background-color: #F4F4F4 !important;
      }
      .theme-secondary-border-color-ie-override {
        border-color: #F4F4F4 !important;
      }
      .theme-highlight-color-ie-override {
        color: #0078a3 !important;
      }
      .theme-highlight-background-color-ie-override {
        background-color: #0078a3 !important;
      }
      .theme-highlight-border-color-ie-override {
        border-color: #0078a3 !important;
      }
    }
  </style>


  <div class="external-content" id="external-content-body">


    






<main class="external-main">

  
    <section class="pinpoint-block pinpoint-block--navigation careers-block careers-navigation-block careers-navigation-block--justified theme-primary-background-color-ie-override" style="">

  <div class=" frow frow--gutters frow--justify-between frow--items-center frow--nowrap">

  <div class="careers-navigation-block__menu-section--left">
    <a style="display: block" href="/">

      <div class="frow frow--items-center frow--gutters">

        <span class="careers-navigation-block__logo-text" style="color: inherit">
          Careers at
        </span>

        <div class="hide-at-sm-block"><img alt="Bath Spa University - Home" style="width: 21.6px; height: 30.0px;" width="21" height="30" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lQTkRRd0xqQjROakF1TUFZNkJrVlUiLCJleHAiOm51bGwsInB1ciI6InZhcmlhdGlvbiJ9fQ==--a8aaf45d691ceff55bb4ecfcc9bec21f806890fa/BSU%20master%20logo.png" /></div><div class="hide-sm-block"><img alt="Bath Spa University - Home" style="width: 36.1px; height: 50.0px;" width="36" height="50" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lRTkRRd0xqQjRNVEF3TGpBR09nWkZWQT09IiwiZXhwIjpudWxsLCJwdXIiOiJ2YXJpYXRpb24ifX0=--5fd990b5737f041b8b006e0f6f8b9bd3043c9631/BSU%20master%20logo.png" /></div>

      </div>

</a>  </div>

  <div class="careers-navigation-block__menu-section--center">

    <script type="application/json" id="js-react-on-rails-context">{"railsEnv":"production","inMailer":false,"i18nLocale":"en","i18nDefaultLocale":"en","rorVersion":"13.0.2","rorPro":false,"href":"https://bathspa.pinpointhq.com/","location":"/","scheme":"https","host":"bathspa.pinpointhq.com","port":null,"pathname":"/","search":null,"httpAcceptLanguage":null,"serverSide":false}</script>
<div class="careers-navigation-overflow-menu" style="" id="External::Careerspage::Responsivenavigation-react-component-852b5a1d-57e9-4209-8b94-4362433f5c32"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Responsivenavigation" data-dom-id="External::Careerspage::Responsivenavigation-react-component-852b5a1d-57e9-4209-8b94-4362433f5c32">{"menuItems":[],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

  <div class="careers-navigation-block__menu-section--right">

      <a class="careers-navigation-block__menu-item" style="" href="/?scroll_to=js-careers-jobs-block">View Jobs</a>

  </div>

</div>


</section>


    <section class="pinpoint-block pinpoint-block--hero careers-hero-block careers-hero-block--align-left careers-hero-block--image" style="background-color: #222222; color: #ffffff; background-image: linear-gradient(rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0.5)), url(https://res.cloudinary.com/pinpointhq/image/upload/f_auto,q_auto/v1/uploads/production/h9mzkgn15hekkvcjcydg);">



      <div class="external-content-wrap careers-hero-block__content-wrap">

        <div class="careers-hero-block__content">

          <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-hero-block__title">Work at Bath Spa University</h2>
            <p class="careers-hero-block__text">Our purpose is to challenge our staff and students to realise their talent and thrive.</p>

          </div>

            <div>
              <a aria-label="" class="external-button external-button--theme-primary mar-b-5 mar-sm-b-10 theme-primary-background-color-ie-override theme-primary-border-color-ie-override" href="#js-careers-jobs-block">View Jobs</a>
            </div>

        </div>

      </div>


</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Our values</h2>

            <div class="careers-block__trix external-panel text-center"><div>At Bath Spa we recognise that equality, diversity and inclusion are essential to building the creative, innovative and nurturing ethos that we pride ourselves on. That’s why <strong>Inclusion</strong> forms one of our four core cultural values alongside <strong>Respect</strong>, <strong>Collaboration </strong>and <strong>Sustainability</strong>.</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--video careers-block">

  <div class="external-content-wrap">

    <div id="External::Careerspage::Video-react-component-c2ed7fd6-fb0e-41c3-86f0-9b842f1fa9ca"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Video" data-dom-id="External::Careerspage::Video-react-component-c2ed7fd6-fb0e-41c3-86f0-9b842f1fa9ca">{"provider":"youtube","videoId":"https://www.youtube.com/embed/oMniClzyzpI?si=64E94e2XuaBamGkj","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-1 careers-card-block careers-card-block--align-left careers-card-block--variant-large">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-sm-7-12 col-sm-order-1 col-order-2">

        <div class="careers-card-block__content">

          
          <h3 class="careers-card-block__h3">Why apply to Bath Spa University?</h3>
          <div class="careers-card-block__p "><div>We are the UK's university of choice for creativity, culture, enterprise and education, and are home to students and staff from over 80 countries. The University is committed to recruiting and retaining the highest quality staff.<br><br>We provide an environment that respects and celebrates all members of our community, and is free from discrimination, prejudice, harassment and bullying. So much so, we are proud to have a wide range of staff networks set-up to foster diversity and inclusion here at Bath Spa. <br><br>These include:</div><ul>
<li>BathSpa+ (for our LGBTQIA+ Staff) </li>
<li>Disabled Staff Network</li>
<li>Women's Staff Network </li>
<li>Neurodiversity Staff Network </li>
<li>Parent and Carers Network </li>
<li>Global Inclusivity Network for staff who identify as Black, Asian, mixed race, or another minoritised ethnicity. </li>
</ul><div>We also have a Staff Equalities Network for colleagues interested in activism and enacting change at a grassroots level.<br><br>These are some of the fab reasons why 82% of our staff said they would recommend us to a friend as a good employer in the last staff survey.<br><br>Carry on scrolling for more great reasons...</div></div>
          

        </div>

      </div>


        <div class="col-sm-5-12 col-sm-order-2 col-order-1">

            <img class="careers-card-block__image cld-responsive" alt="" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,q_auto,w_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /><noscript><img class="careers-card-block__image" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /></noscript>


        </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--image-gallery careers-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div id="External::Careerspage::Imagegallery-react-component-3b891fac-773c-401c-aef5-0cd2b4d39a08"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Imagegallery" data-dom-id="External::Careerspage::Imagegallery-react-component-3b891fac-773c-401c-aef5-0cd2b4d39a08">{"cloudinaryImages":[{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/lpwat6i2mpwpgzkomc68","width":5332,"height":3552,"alt":"","publicId":"uploads/production/lpwat6i2mpwpgzkomc68"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/gxj4mi4kl0oxer7wdwgi","width":1000,"height":1000,"alt":"","publicId":"uploads/production/gxj4mi4kl0oxer7wdwgi"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/otke5vlkmrg6a5gp0hxl","width":1000,"height":1500,"alt":"","publicId":"uploads/production/otke5vlkmrg6a5gp0hxl"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/iqzgcwcu2zr0358ckf37","width":7952,"height":5304,"alt":"","publicId":"uploads/production/iqzgcwcu2zr0358ckf37"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/toiyerugdnkgji0dsfyh","width":5125,"height":3417,"alt":"","publicId":"uploads/production/toiyerugdnkgji0dsfyh"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/zrw1nruistevzollfwuu","width":5760,"height":3840,"alt":"","publicId":"uploads/production/zrw1nruistevzollfwuu"}],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Benefits</h2>

            <div class="careers-block__trix external-panel text-center">We work hard, but we also know you have a family, friends, hobbies, and a life outside the office. That’s why we offer a great benefits package, not just a competitive salary.</div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /></noscript>
          <h3 class="careers-card-block__h3">41 days holiday</h3>
          <div class="careers-card-block__p "><div>This includes bank holidays and University closure days. Everyone needs a healthy, happy, and productive life. This means you'll need time to rest and recover.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /></noscript>
          <h3 class="careers-card-block__h3">Generous pension plans</h3>
          <div class="careers-card-block__p "><div>We've got you covered for the future. Work in the comfort of knowing that all your hard work is not only paying off now but also setting you up for the future.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /></noscript>
          <h3 class="careers-card-block__h3">Flexible working</h3>
          <div class="careers-card-block__p "><div>We know life is busy so, where we can, we support flexible working to ensure our teams are happy, productive and listened to.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /></noscript>
          <h3 class="careers-card-block__h3">Onsite nursery </h3>
          <div class="careers-card-block__p "><div>Reduce the morning stress by dropping the kids off at the onsite nursery. We've got you and your family covered.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /></noscript>
          <h3 class="careers-card-block__h3">Employee assistance programme </h3>
          <div class="careers-card-block__p "><div>We've teamed up with Telus Health to provide you with extra support when needed. Whether it is health, family, money, work or yourself, Telus Health is only a phone call away.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /></noscript>
          <h3 class="careers-card-block__h3">A team that cares</h3>
          <div class="careers-card-block__p "><div>You’ll be joining a team of smart, capable, helpful people that want you to win, our students to win and our University and community to grow. Not to mention our team of care dogs who are on hand to put a smile on your face if needed.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--column-start ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-left">We asked our teams...</h2>

            <div class="careers-block__trix external-panel text-left"><div>"Beyond pay and benefits, what things make Bath Spa a great place to work?"</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--carousel careers-block careers-carousel-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


      <div id="External::Careerspage::Carousel-react-component-f6189f04-ad39-49dc-9bd4-4904d8a1fb14"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Carousel" data-dom-id="External::Careerspage::Carousel-react-component-f6189f04-ad39-49dc-9bd4-4904d8a1fb14">{"renderedBlocks":["\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The sense of community, my colleagues, the students, the campus, the general atmosphere of positivity and appreciation.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Sarah \n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;A culture that support equal access for staff and students.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Meg\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;Beautiful campus with the opportunity to learn new things from those around us. Also,\na good team working atmosphere where team members are willing to help and support each other. Cultivating a fun, happy and hard-working culture where everyone feels valued.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Simon\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The people are wonderful - their values are ones I agree with and try to live by.\n\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Suman\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e"],"autoplay":false,"autoplaySpeedMs":10000,"showDots":true,"infinite":true,"scrollAmount":1,"showAmount":1,"scrollSpeedMs":500,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

</div>
</section>


    <section class="pinpoint-block pinpoint-block--jobs careers-block" id="js-careers-jobs-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <h2 class="careers-block__h2 text-center">Current Opportunities</h2>

      <div class="careers-block__content pad-b-3">

        <div class="frow frow--gutters frow--gutters-md-2x frow--items-end">

          <div class="col-flex-grow-1">

            <form role="search">
              <button type="submit" disabled style="display: none" aria-hidden="true"></button>
              <div id="Shared::Search-react-component-2a1a427d-1996-4a44-96ce-107fd4bcd5c6"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="Shared::Search" data-dom-id="Shared::Search-react-component-2a1a427d-1996-4a44-96ce-107fd4bcd5c6">{"target":"external:jobs:index:5494","willUpdateUrl":true,"searchPlaceholderText":"Search...","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      

            </form>

          </div>


            <div class="col-md-6-12">
              <div id="External::Filters-react-component-bae48e52-3186-413a-8f5b-ab7a66770c9f"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Filters" data-dom-id="External::Filters-react-component-bae48e52-3186-413a-8f5b-ab7a66770c9f">{"filters":[{"name":"location","attribute":"location_id","values":[],"items":[{"label":"Bath","value":10393},{"label":"Bath - Corsham Court","value":14961},{"label":"Bath - Locksbrook Campus","value":14959},{"label":"Bath - Newton Park","value":14958},{"label":"Bath - Newton Park \u0026 Locksbrook","value":14962},{"label":"Bath - Palace Yard Mews","value":17471},{"label":"Bath - Sion Hill Campus","value":14960},{"label":"Bath Spa University London","value":23470},{"label":"London - New City College ","value":14963},{"label":"Remote","value":27327},{"label":"The Studio - Palace Yard Mews","value":26635},{"label":"Various - Across SW England ","value":28564}],"translations":{"singleItem":"Location","pluralItems":"Locations","allItems":"All Locations"}},{"name":"department","attribute":"department_id","values":[],"items":[{"label":" Innovation and Knowledge Exchange Centre","value":37689},{"label":"Academic Planning","value":19086},{"label":"Art, Film \u0026 Media ","value":41507},{"label":"Bath Business school - London ","value":34431},{"label":"Bath School of Music and Performing Arts ","value":31904},{"label":"Bath Spa University London ","value":29962},{"label":"Business School","value":19085},{"label":"Careers and Employability","value":28533},{"label":"Catering ","value":34135},{"label":"Centre for Educational Partnerships ","value":38139},{"label":"Chancelry","value":25472},{"label":"Data \u0026 Insights Service","value":33104},{"label":"EAU","value":32064},{"label":"EAU Short Courses","value":29808},{"label":"Estates","value":25473},{"label":"Estates and Services","value":30675},{"label":"Estates/Security","value":30951},{"label":"External Affairs Unit","value":25474},{"label":"Facilities and Services","value":30050},{"label":"Finance","value":25475},{"label":"Future Students","value":31406},{"label":"Governance \u0026 Engagement ","value":35154},{"label":"Governance Legal \u0026 Compliance","value":25476},{"label":"HR","value":19087},{"label":"IT Services","value":25477},{"label":"Learning Innovation \u0026 Skills Unit /  Schools Technical Services","value":34216},{"label":"Learning, Innovation and Skills","value":36124},{"label":"Learning, Innovation and Skills: Academic Skills","value":28307},{"label":"Library and Learning Services","value":28326},{"label":"Marketing and Applicant Comms, Future Students ","value":29815},{"label":"Portfolio and Planning","value":30409},{"label":"Research \u0026 Enterprise","value":25478},{"label":"Research \u0026 Graduate Affairs","value":33220},{"label":"School Of Science","value":29645},{"label":"School of Art, Film \u0026 Media","value":36272},{"label":"School of Design","value":19088},{"label":"School of Education","value":25479},{"label":"School of Film \u0026 Arts","value":19084},{"label":"School of Music \u0026 Performing Arts","value":19083},{"label":"School of Science","value":29646},{"label":"School of Sciences","value":25480},{"label":"School of Writing Publishing \u0026 Humanities","value":25481},{"label":"School of Writing, Publishing and the Humanities","value":29246},{"label":"Strategic Projects \u0026 Delivery Unit","value":25482},{"label":"Strategic Projects and Change Unit","value":36037},{"label":"Student Accommodation ","value":35035},{"label":"Student Experience","value":25483},{"label":"Student Housing ","value":33411},{"label":"Student Wellbeing SErvices","value":31929},{"label":"Student Wellbeing Services ","value":28279},{"label":"Student and Registry Services","value":29262},{"label":"Student wellbeing Services","value":31930},{"label":"Technical Services","value":30746},{"label":"Wellbeing \u0026 Disability","value":30147},{"label":"Writing, Publishing \u0026 Humanities ","value":29781}],"translations":{"singleItem":"Department","pluralItems":"Departments","allItems":"All Departments"}}],"isUrlFilterable":true,"target":"external:jobs:index:5494","willUpdateUrl":true,"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


            </div>


        </div>

      </div>

    </div>

  </div>


  <div id="External::Jobs-react-component-b3d2d201-a657-414c-acc4-c897fa378464"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Jobs" data-dom-id="External::Jobs-react-component-b3d2d201-a657-414c-acc4-c897fa378464">{"additionalColumns":[],"url":"/postings.json","target":"external:jobs:index:5494","translations":{"job_title":"Job Title","department":"Department","division":"Division","requisition_id":"Requisition ID","structure_custom_group_one":"Custom","location":"Location","employment_type":"Employment Type","no_positions":"There are currently no positions advertised.","no_opportunities":"There are currently no opportunities based on your filters. Please try again, or register your interest.","workplace_type":"Workplace type"},"structures":[{"key":"location","keyPlural":"locations","name":"Location","namePlural":"Locations","nameAccessor":"locationName","columnVisibilityAccessor":"locationsColumnVisible"},{"key":"department","keyPlural":"departments","name":"Department","namePlural":"Departments","nameAccessor":"departmentName","columnVisibilityAccessor":"departmentsColumnVisible"}],"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"showPagination":false,"pageSize":null,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      



</section>



</main>


  </div>

    <footer class="external-footer theme-secondary-background-color-ie-override" id="external-content-footer">

  <div class="external-content-wrap">


    <div class="external-footer__content">

      <div class="frow frow--justify-between frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-3x">

        <div>

          <div class="frow frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-2x">


              <a class="external-footer__link" target="_blank" href="https://www.bathspa.ac.uk/">

                Bath Spa University <i class="fas fa-external-link-alt mar-l-1"></i>

</a>

            <a class="external-footer__link" target="_blank" href="/themes/2198/privacy_policy">
              Privacy Policy
</a>
              <a class='external-footer__link' data-cc="c-settings" aria-label="View cookie settings" tabindex="0" role="button">
                Cookies
              </a>

            <div class="frow frow--gutters frow--items-center">
              <a class="external-footer__link" href="https://www.facebook.com/bath.spa.university" target="_blank" title="Bath Spa University&#39;s Facebook page." style="margin-right: 5px;"><i class="fab fa-facebook fa-lg" style="color: #3B5998"></i></a>
              
              
              
              <a class="external-footer__link" href="https://www.instagram.com/bathspauni" target="_blank" title="Bath Spa University&#39;s Instagram page." style="margin-right: 5px;"><img alt="Bath Spa University instagram" src="https://d2n5ied94mazop.cloudfront.net/packs/static/logos/external/instagram_logo-5139d56ff0927cddd11f.svg" /></a>
              
            </div>

          </div>

        </div>

        <div>

          <a class="external-footer__link" target="_blank" href="https://www.pinpointhq.com">Powered by Pinpoint</a>

        </div>

      </div>

    </div>

  </div>

  </div>

</footer>


  







    <script nonce="d0ec80cf883a87fd072ede6364f7fdd8">
  // Ensures that the stuff in the iframe doesn't take focus
  setTimeout(() => {
    var frames = document.getElementsByTagName("iframe");
    for (i = 0; i < frames.length; ++i) {
      frames[i].setAttribute("tabindex", "-1");
    }
  }, 1000)
</script>


</body>

-  recorded_at: Mon, 29 Jul 2024 09:07:00 GMT
+        <!DOCTYPE html>
<html lang="en-GB">
<head>
<script nonce="5b08b3e58a1af308e956005a8a13b467">var _rollbarConfig = {"accessToken":"0ab41f8274e04d638238b61af91c297a","captureUncaught":true,"payload":{"environment":"production"},"ignoredMessages":["SP401 - Unauthorized"],"checkIgnore":function(isUncaught, args, payload) {
  var message = args[0];
  var ignoredMobileMessages = [
    `Uncaught SyntaxError: Unexpected token ';'`,
    `SyntaxError: Unexpected token ';'. Expected ')' to end a compound expression.`
  ];
  var userAgentContainsMobile = window && window.navigator && window.navigator.userAgent && window.navigator.userAgent.indexOf('Mobile') !== -1;
  if(userAgentContainsMobile && ignoredMobileMessages.includes(message)) {
    // ignore this message
    return true;
  }
  var ignoredMessages = [
    `ResizeObserver loop completed with undelivered notifications.`,
    `Script error.`
  ];
  if(ignoredMessages.includes(message)) {
    // ignore this message
    return true;
  }
}
};</script>
<script nonce="5b08b3e58a1af308e956005a8a13b467">!function(r){var e={};function o(n){if(e[n])return e[n].exports;var t=e[n]={i:n,l:!1,exports:{}};return r[n].call(t.exports,t,t.exports,o),t.l=!0,t.exports}o.m=r,o.c=e,o.d=function(r,e,n){o.o(r,e)||Object.defineProperty(r,e,{enumerable:!0,get:n})},o.r=function(r){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(r,"__esModule",{value:!0})},o.t=function(r,e){if(1&e&&(r=o(r)),8&e)return r;if(4&e&&"object"==typeof r&&r&&r.__esModule)return r;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:r}),2&e&&"string"!=typeof r)for(var t in r)o.d(n,t,function(e){return r[e]}.bind(null,t));return n},o.n=function(r){var e=r&&r.__esModule?function(){return r.default}:function(){return r};return o.d(e,"a",e),e},o.o=function(r,e){return Object.prototype.hasOwnProperty.call(r,e)},o.p="",o(o.s=0)}([function(r,e,o){"use strict";var n=o(1),t=o(5);_rollbarConfig=_rollbarConfig||{},_rollbarConfig.rollbarJsUrl=_rollbarConfig.rollbarJsUrl||"https://cdn.rollbar.com/rollbarjs/refs/tags/v2.26.1/rollbar.min.js",_rollbarConfig.async=void 0===_rollbarConfig.async||_rollbarConfig.async;var a=n.setupShim(window,_rollbarConfig),l=t(_rollbarConfig);window.rollbar=n.Rollbar,a.loadFull(window,document,!_rollbarConfig.async,_rollbarConfig,l)},function(r,e,o){"use strict";var n=o(2),t=o(3);function a(r){return function(){try{return r.apply(this,arguments)}catch(r){try{console.error("[Rollbar]: Internal error",r)}catch(r){}}}}var l=0;function i(r,e){this.options=r,this._rollbarOldOnError=null;var o=l++;this.shimId=function(){return o},"undefined"!=typeof window&&window._rollbarShims&&(window._rollbarShims[o]={handler:e,messages:[]})}var s=o(4),d=function(r,e){return new i(r,e)},c=function(r){return new s(d,r)};function u(r){return a((function(){var e=this,o=Array.prototype.slice.call(arguments,0),n={shim:e,method:r,args:o,ts:new Date};window._rollbarShims[this.shimId()].messages.push(n)}))}i.prototype.loadFull=function(r,e,o,n,t){var l=!1,i=e.createElement("script"),s=e.getElementsByTagName("script")[0],d=s.parentNode;i.crossOrigin="",i.src=n.rollbarJsUrl,o||(i.async=!0),i.onload=i.onreadystatechange=a((function(){if(!(l||this.readyState&&"loaded"!==this.readyState&&"complete"!==this.readyState)){i.onload=i.onreadystatechange=null;try{d.removeChild(i)}catch(r){}l=!0,function(){var e;if(void 0===r._rollbarDidLoad){e=new Error("rollbar.js did not load");for(var o,n,a,l,i=0;o=r._rollbarShims[i++];)for(o=o.messages||[];n=o.shift();)for(a=n.args||[],i=0;i<a.length;++i)if("function"==typeof(l=a[i])){l(e);break}}"function"==typeof t&&t(e)}()}})),d.insertBefore(i,s)},i.prototype.wrap=function(r,e,o){try{var n;if(n="function"==typeof e?e:function(){return e||{}},"function"!=typeof r)return r;if(r._isWrap)return r;if(!r._rollbar_wrapped&&(r._rollbar_wrapped=function(){o&&"function"==typeof o&&o.apply(this,arguments);try{return r.apply(this,arguments)}catch(o){var e=o;throw e&&("string"==typeof e&&(e=new String(e)),e._rollbarContext=n()||{},e._rollbarContext._wrappedSource=r.toString(),window._rollbarWrappedError=e),e}},r._rollbar_wrapped._isWrap=!0,r.hasOwnProperty))for(var t in r)r.hasOwnProperty(t)&&(r._rollbar_wrapped[t]=r[t]);return r._rollbar_wrapped}catch(e){return r}};for(var p="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,captureEvent,captureDomContentLoaded,captureLoad".split(","),f=0;f<p.length;++f)i.prototype[p[f]]=u(p[f]);r.exports={setupShim:function(r,e){if(r){var o=e.globalAlias||"Rollbar";if("object"==typeof r[o])return r[o];r._rollbarShims={},r._rollbarWrappedError=null;var l=new c(e);return a((function(){e.captureUncaught&&(l._rollbarOldOnError=r.onerror,n.captureUncaughtExceptions(r,l,!0),e.wrapGlobalEventHandlers&&t(r,l,!0)),e.captureUnhandledRejections&&n.captureUnhandledRejections(r,l,!0);var a=e.autoInstrument;return!1!==e.enabled&&(void 0===a||!0===a||function(r){return!("object"!=typeof r||void 0!==r.page&&!r.page)}(a))&&r.addEventListener&&(r.addEventListener("load",l.captureLoad.bind(l)),r.addEventListener("DOMContentLoaded",l.captureDomContentLoaded.bind(l))),r[o]=l,l}))()}},Rollbar:c}},function(r,e,o){"use strict";function n(r,e,o,n){r._rollbarWrappedError&&(n[4]||(n[4]=r._rollbarWrappedError),n[5]||(n[5]=r._rollbarWrappedError._rollbarContext),r._rollbarWrappedError=null);var t=e.handleUncaughtException.apply(e,n);o&&o.apply(r,n),"anonymous"===t&&(e.anonymousErrorsPending+=1)}r.exports={captureUncaughtExceptions:function(r,e,o){if(r){var t;if("function"==typeof e._rollbarOldOnError)t=e._rollbarOldOnError;else if(r.onerror){for(t=r.onerror;t._rollbarOldOnError;)t=t._rollbarOldOnError;e._rollbarOldOnError=t}e.handleAnonymousErrors();var a=function(){var o=Array.prototype.slice.call(arguments,0);n(r,e,t,o)};o&&(a._rollbarOldOnError=t),r.onerror=a}},captureUnhandledRejections:function(r,e,o){if(r){"function"==typeof r._rollbarURH&&r._rollbarURH.belongsToShim&&r.removeEventListener("unhandledrejection",r._rollbarURH);var n=function(r){var o,n,t;try{o=r.reason}catch(r){o=void 0}try{n=r.promise}catch(r){n="[unhandledrejection] error getting `promise` from event"}try{t=r.detail,!o&&t&&(o=t.reason,n=t.promise)}catch(r){}o||(o="[unhandledrejection] error getting `reason` from event"),e&&e.handleUnhandledRejection&&e.handleUnhandledRejection(o,n)};n.belongsToShim=o,r._rollbarURH=n,r.addEventListener("unhandledrejection",n)}}}},function(r,e,o){"use strict";function n(r,e,o){if(e.hasOwnProperty&&e.hasOwnProperty("addEventListener")){for(var n=e.addEventListener;n._rollbarOldAdd&&n.belongsToShim;)n=n._rollbarOldAdd;var t=function(e,o,t){n.call(this,e,r.wrap(o),t)};t._rollbarOldAdd=n,t.belongsToShim=o,e.addEventListener=t;for(var a=e.removeEventListener;a._rollbarOldRemove&&a.belongsToShim;)a=a._rollbarOldRemove;var l=function(r,e,o){a.call(this,r,e&&e._rollbar_wrapped||e,o)};l._rollbarOldRemove=a,l.belongsToShim=o,e.removeEventListener=l}}r.exports=function(r,e,o){if(r){var t,a,l="EventTarget,Window,Node,ApplicationCache,AudioTrackList,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");for(t=0;t<l.length;++t)r[a=l[t]]&&r[a].prototype&&n(e,r[a].prototype,o)}}},function(r,e,o){"use strict";function n(r,e){this.impl=r(e,this),this.options=e,function(r){for(var e=function(r){return function(){var e=Array.prototype.slice.call(arguments,0);if(this.impl[r])return this.impl[r].apply(this.impl,e)}},o="log,debug,info,warn,warning,error,critical,global,configure,handleUncaughtException,handleAnonymousErrors,handleUnhandledRejection,_createItem,wrap,loadFull,shimId,captureEvent,captureDomContentLoaded,captureLoad".split(","),n=0;n<o.length;n++)r[o[n]]=e(o[n])}(n.prototype)}n.prototype._swapAndProcessMessages=function(r,e){var o,n,t;for(this.impl=r(this.options);o=e.shift();)n=o.method,t=o.args,this[n]&&"function"==typeof this[n]&&("captureDomContentLoaded"===n||"captureLoad"===n?this[n].apply(this,[t[0],o.ts]):this[n].apply(this,t));return this},r.exports=n},function(r,e,o){"use strict";r.exports=function(r){return function(e){if(!e&&!window._rollbarInitialized){for(var o,n,t=(r=r||{}).globalAlias||"Rollbar",a=window.rollbar,l=function(r){return new a(r)},i=0;o=window._rollbarShims[i++];)n||(n=o.handler),o.handler._swapAndProcessMessages(l,o.messages);window[t]=n,window._rollbarInitialized=!0}}}}]);</script>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  
  <title>Jobs at Bath Spa University | Bath Spa University Careers</title>
  <meta name="description" content="Learn more about working at Bath Spa University and discover our latest career opportunities">

  <style>
    :root {
      --theme-primary-color: #455C51;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #ED9D85;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <script nonce="5b08b3e58a1af308e956005a8a13b467">
//<![CDATA[

    window.essentialCookiesOnly = false;

    window.legacyCookieData = {"href":"/cookie-policy","message":"We use cookies to ensure you get the best experience on our website.","dismiss":"Got it!","link":"Learn more"};

    window.cookieConsentData = {"customContent":{"notice":"We use cookies to ensure you get the best experience on our website.","explanation":"We use cookies to ensure the basic functionalities of the website and to enhance your online experience. You can choose for each category to opt-in/out whenever you want. For more details relative to cookies and other sensitive data, please read the full <a href='/cookie-policy'>privacy policy</a>.","further_information":null},"translations":{"accept_all":"Accept all","close":"Close","cookie_preferences":"Cookie preferences","cookies":"Cookies","description":"Description","domain":"Domain","expiration":"Expiration","more_information":"More information","name":"Name","reject_all":"Reject all","save_settings":"Save settings","settings":"Settings","strictly_necessary_cookies":"Strictly necessary cookies","these_cookies_are_essential":"These cookies are essential for the proper functioning of our website. Without these cookies, the website may not work properly.","as_soon_as_browser_window_is_closed":"As soon as browser window is closed","allows_us_to_associate_file_uploads":"Allows us to associate file uploads to our file storage provider with your form submissions","allows_our_load_balancer":"Allows our load balancer to send your specific traffic to the same backend server","saves_your_decisions":"Saves your decisions about these cookies so we don't need to ask every time","analytics_and_performance_cookies":"Analytics and Performance cookies","these_cookies_remember_the_choices":"These cookies allow the website to remember the choices you have made in the past","internal_metrics_collector":"We use an internal metrics collector to understand interactions with our website over time","six_months":"Six months","two_years":"Two years","four_hours":"Four hours"}};

//]]>
</script>
  <script src="https://d2n5ied94mazop.cloudfront.net/packs/js/runtime-4ee0bc422406a939a04f.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/8860-54ebbc9015ed0678f9b4.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/application-7fc02963bbe1c1231110.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/7758-500534d14de13d6d913d.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/4934-7ef1df48c38cb8a32707.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cloudinary-4e5eb5d8dc0e193d4cef.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cookieconsent-76ba7ccf84597c35e667.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/cdp-84feff2ddc8a9978561d.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
<script src="https://d2n5ied94mazop.cloudfront.net/packs/js/gtm-data-layer-9c7afd0f3a5aa7c9719c.js" data-turbolinks-track="reload" nonce="5b08b3e58a1af308e956005a8a13b467" defer="defer"></script>
  <link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/application-79f60752.css" data-turbolinks-track="reload" />
<link rel="stylesheet" media="screen" href="https://d2n5ied94mazop.cloudfront.net/packs/css/cookieconsent-4c4dfb09.css" data-turbolinks-track="reload" />

  <meta name="turbolinks-cache-control" content="no-preview">

  <meta name="csrf-param" content="authenticity_token" />
<meta name="csrf-token" content="+IkRasiQ52lNnHZRKQX+kfglqetjmsA4N24ld+STWxgYcSbUFVK939MtKpSBBhuIDbKwsChLPG38a7TLWHjp7Q==" />
  <meta name="csp-nonce" content="5b08b3e58a1af308e956005a8a13b467" />

  <link rel="shortcut icon" type="image/x-icon" href="https://res.cloudinary.com/pinpointhq/image/upload/c_fill,f_auto,h_32,q_auto,w_32/v1/uploads/production/lyby5aqq3zkcbluwtwgv.png" />

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <script src="https://kit.fontawesome.com/832bb86d52.js" crossorigin="anonymous" nonce="5b08b3e58a1af308e956005a8a13b467"></script>

  

    <link rel="alternate" type="application/rss+xml" title="RSS" href="https://bathspa.pinpointhq.com/jobs.rss" />


  
    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;600;700&amp;display=swap" rel="stylesheet">
    <style>
      body,
      input {
        font-family: Montserrat, "GTWalsheimPro", "Helvetica Neue", "Helvetica", sans-serif !important;
      }
    </style>


  
    <style type="text/css">
      /* (Default Options) Custom Type to allow us to use both of our brand typefaces in heros etc */
.pinpoint-block--hero .careers-hero-block__title {
font-weight: 700;
}
.pinpoint-block--text .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
margin-bottom: 20px;
}
.pinpoint-block--text .careers-block__trix {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--cards .careers-card-block__h3 {
font-weight: 700;
line-height: 1.2;
}
.pinpoint-block--cards .careers-card-block__p {
font-weight: 400;
line-height: 1.6;
color: #4D4D4D;
}
.pinpoint-block--jobs .careers-block__h2 {
font-weight: 700;
font-size: 4rem;
line-height: 1.1;
}

/* (Default Options) Custom Footer */
.external-footer {
padding: 32px;
}

/* (Default Options) Testimonial Block */
.pinpoint-block--testimonial img {
border-radius: 185px;
}
.pinpoint-block--testimonial cite {
font-weight: 700 !important;
letter-spacing: 3px;
}
.pinpoint-block--testimonial .careers-testimonial-block {
align-items: center;
}

/* (Default Options) External Panels - e.g. titles on JDs, Interview Scheduling, etc.) */
.external-panel .external-panel__title {
font-weight: 700;
}

/* (Default Options) Custom Hero Image Positioning */
.careers-hero-block--image {
background-position: center;
}

/* (Default Options) Hide the Logo Text */
.careers-navigation-block__logo-text,
.careers-hero-block__logo-text {
display: none;
}

/* (Default Options) Make hero bigger because people like to see video and pictures */
.careers-hero-block-container {
padding-top: 80px !important;
padding-bottom: 80px !important;
}

/* --------------------------- AS ----------------------------- */

/* Customize navbar */
.pinpoint-block--navigation {
  padding-top: 5px;
  padding-bottom: 5px;
  background-color: #ffffff;
}

/* Set logo width */
@media (min-width: 768px) {
  .pinpoint-block--navigation img,
  .careers-hero-block--align-center img {
    width: 60px !important;
    height: auto !important;
  }
}

/* Customize nav items */
.careers-navigation-block__menu-item {
  color: #6D6D6D !important;
  background-color: transparent !important;
  text-transform: uppercase;
}

.careers-navigation-block__sub-nav-menu {
  color: #6D6D6D !important;
  background-color: #ffffff !important;
}

.careers-navigation-block__menu-section--center > div > div > .careers-navigation-block__menu-item > div {
  box-shadow: 0px 0px 10px -4px rgb(0 0 0 / 45%);
  overflow: hidden;
}

.careers-navigation-block__menu-item:hover,
.careers-navigation-block__sub-nav-menu:hover {
  color: #007EAC !important;
}

/* Update some of the styles to meet accessibility requirements */
.external-definition-list dt {
  color: #0078A3;
}

#js-careers-jobs-block,
.external-definition-list dd,
.external-definition-list dd 
.link--default,
.text-brand-ash-grey{
  color: #5c5c5c !important;
}

.external-button:focus, 
.external-button:active,
.link:focus,
.search__input:focus,
.filter .filter__button:focus {
  outline: 2px solid #2a8853 !important;
}

.external-button--theme-highlight:hover {
  background-color: #004f66;
}

.slick-dots li button:hover, .slick-dots li button:focus {
  outline: 1px solid #2a8853 !important;
}

/* Fix the placeholder colors */
input::placeholder,
.checkable-input__label,
.react-select .react-select__placeholder {
  color: #6F6F6F !important;
  opacity: 1;
}
    </style>


    




  

  <meta property="og:url" content="https://bathspa.pinpointhq.com/">
<meta property="og:type" content="website">
<meta property="og:locale" content="en_GB">
<meta property="og:title" content="Careers at Bath Spa University">
<meta property="og:description" content="Bath Spa University is where creative minds meet. Offering a wide range of courses across the arts, sciences, education, social science and business to over 7,500 students, the University employs outstanding creative professionals which support its aim to be a leading educational institution...">
<meta property="og:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@pinpointhq">
<meta name="twitter:image" content="https://app.pinpointhq.com/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBeHY2bkE9PSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--4bda0d4eb64d9fe6228f5d0b089c0f4c7b6d5468/open_graph.png">

  <script nonce="5b08b3e58a1af308e956005a8a13b467">
//<![CDATA[

    window.railsEnv = "production";

//]]>
</script>
  

    <link href="https://bathspa.pinpointhq.com/" rel="canonical" />
</head>

<body dir='auto' class="external-body pinpoint-page pinpoint-page--home theme-default">

  

  
  <style>
    :root {
      --theme-primary-color: #007eac;
      --theme-secondary-color: #F4F4F4;
      --theme-highlight-color: #0078a3;
      --theme-primary-font-color: #FFFFFF;
      --theme-secondary-font-color: #1C2121;
      --theme-highlight-font-color: #FFFFFF;
    }
  </style>

  <style>
    @media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {
      .theme-primary-color-ie-override {
        color: #007eac !important;
      }
      .theme-primary-background-color-ie-override {
        background-color: #007eac !important;
      }
      .theme-primary-border-color-ie-override {
        border-color: #007eac !important;
      }
      .theme-secondary-color-ie-override {
        color: #F4F4F4 !important;
      }
      .theme-secondary-background-color-ie-override {
        background-color: #F4F4F4 !important;
      }
      .theme-secondary-border-color-ie-override {
        border-color: #F4F4F4 !important;
      }
      .theme-highlight-color-ie-override {
        color: #0078a3 !important;
      }
      .theme-highlight-background-color-ie-override {
        background-color: #0078a3 !important;
      }
      .theme-highlight-border-color-ie-override {
        border-color: #0078a3 !important;
      }
    }
  </style>


  <div class="external-content" id="external-content-body">


    






<main class="external-main">

  
    <section class="pinpoint-block pinpoint-block--navigation careers-block careers-navigation-block careers-navigation-block--justified theme-primary-background-color-ie-override" style="">

  <div class=" frow frow--gutters frow--justify-between frow--items-center frow--nowrap">

  <div class="careers-navigation-block__menu-section--left">
    <a style="display: block" href="/">

      <div class="frow frow--items-center frow--gutters">

        <span class="careers-navigation-block__logo-text" style="color: inherit">
          Careers at
        </span>

        <div class="hide-at-sm-block"><img alt="Bath Spa University - Home" style="width: 21.6px; height: 30.0px;" width="21" height="30" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lQTkRRd0xqQjROakF1TUFZNkJrVlUiLCJleHAiOm51bGwsInB1ciI6InZhcmlhdGlvbiJ9fQ==--a8aaf45d691ceff55bb4ecfcc9bec21f806890fa/BSU%20master%20logo.png" /></div><div class="hide-sm-block"><img alt="Bath Spa University - Home" style="width: 36.1px; height: 50.0px;" width="36" height="50" src="https://app.pinpointhq.com/rails/active_storage/representations/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBCSGg5QXdFPSIsImV4cCI6bnVsbCwicHVyIjoiYmxvYl9pZCJ9fQ==--f98690ddbf42eb24aebb62aab838f92aedc8ce71/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaDdCam9MY21WemFYcGxTU0lRTkRRd0xqQjRNVEF3TGpBR09nWkZWQT09IiwiZXhwIjpudWxsLCJwdXIiOiJ2YXJpYXRpb24ifX0=--5fd990b5737f041b8b006e0f6f8b9bd3043c9631/BSU%20master%20logo.png" /></div>

      </div>

</a>  </div>

  <div class="careers-navigation-block__menu-section--center">

    <script type="application/json" id="js-react-on-rails-context">{"railsEnv":"production","inMailer":false,"i18nLocale":"en","i18nDefaultLocale":"en","rorVersion":"13.0.2","rorPro":false,"href":"https://bathspa.pinpointhq.com/","location":"/","scheme":"https","host":"bathspa.pinpointhq.com","port":null,"pathname":"/","search":null,"httpAcceptLanguage":null,"serverSide":false}</script>
<div class="careers-navigation-overflow-menu" style="" id="External::Careerspage::Responsivenavigation-react-component-57eceb45-0781-4b19-89f1-e2552b6e79d1"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Responsivenavigation" data-dom-id="External::Careerspage::Responsivenavigation-react-component-57eceb45-0781-4b19-89f1-e2552b6e79d1">{"menuItems":[],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

  <div class="careers-navigation-block__menu-section--right">

      <a class="careers-navigation-block__menu-item" style="" href="/?scroll_to=js-careers-jobs-block">View Jobs</a>

  </div>

</div>


</section>


    <section class="pinpoint-block pinpoint-block--hero careers-hero-block careers-hero-block--align-left careers-hero-block--image" style="background-color: #222222; color: #ffffff; background-image: linear-gradient(rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0.5)), url(https://res.cloudinary.com/pinpointhq/image/upload/f_auto,q_auto/v1/uploads/production/h9mzkgn15hekkvcjcydg);">



      <div class="external-content-wrap careers-hero-block__content-wrap">

        <div class="careers-hero-block__content">

          <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-hero-block__title">Work at Bath Spa University</h2>
            <p class="careers-hero-block__text">Our purpose is to challenge our staff and students to realise their talent and thrive.</p>

          </div>

            <div>
              <a aria-label="" class="external-button external-button--theme-primary mar-b-5 mar-sm-b-10 theme-primary-background-color-ie-override theme-primary-border-color-ie-override" href="#js-careers-jobs-block">View Jobs</a>
            </div>

        </div>

      </div>


</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Our values</h2>

            <div class="careers-block__trix external-panel text-center"><div>At Bath Spa we recognise that equality, diversity and inclusion are essential to building the creative, innovative and nurturing ethos that we pride ourselves on. That’s why <strong>Inclusion</strong> forms one of our four core cultural values alongside <strong>Respect</strong>, <strong>Collaboration </strong>and <strong>Sustainability</strong>.</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--video careers-block">

  <div class="external-content-wrap">

    <div id="External::Careerspage::Video-react-component-7e095835-bf2d-4fe1-8e47-a0c8521580e6"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Video" data-dom-id="External::Careerspage::Video-react-component-7e095835-bf2d-4fe1-8e47-a0c8521580e6">{"provider":"youtube","videoId":"https://www.youtube.com/embed/oMniClzyzpI?si=64E94e2XuaBamGkj","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-1 careers-card-block careers-card-block--align-left careers-card-block--variant-large">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-sm-7-12 col-sm-order-1 col-order-2">

        <div class="careers-card-block__content">

          
          <h3 class="careers-card-block__h3">Why apply to Bath Spa University?</h3>
          <div class="careers-card-block__p "><div>We are the UK's university of choice for creativity, culture, enterprise and education, and are home to students and staff from over 80 countries. The University is committed to recruiting and retaining the highest quality staff.<br><br>We provide an environment that respects and celebrates all members of our community, and is free from discrimination, prejudice, harassment and bullying. So much so, we are proud to have a wide range of staff networks set-up to foster diversity and inclusion here at Bath Spa. <br><br>These include:</div><ul>
<li>BathSpa+ (for our LGBTQIA+ Staff) </li>
<li>Disabled Staff Network</li>
<li>Women's Staff Network </li>
<li>Neurodiversity Staff Network </li>
<li>Parent and Carers Network </li>
<li>Global Inclusivity Network for staff who identify as Black, Asian, mixed race, or another minoritised ethnicity. </li>
</ul><div>We also have a Staff Equalities Network for colleagues interested in activism and enacting change at a grassroots level.<br><br>These are some of the fab reasons why 82% of our staff said they would recommend us to a friend as a good employer in the last staff survey.<br><br>Carry on scrolling for more great reasons...</div></div>
          

        </div>

      </div>


        <div class="col-sm-5-12 col-sm-order-2 col-order-1">

            <img class="careers-card-block__image cld-responsive" alt="" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,q_auto,w_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /><noscript><img class="careers-card-block__image" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/uploads/production/eidhuznpdf8hlmutsf0m" /></noscript>


        </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--image-gallery careers-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div id="External::Careerspage::Imagegallery-react-component-1121d5ba-f07e-4e2b-aa25-8e137594c47b"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Imagegallery" data-dom-id="External::Careerspage::Imagegallery-react-component-1121d5ba-f07e-4e2b-aa25-8e137594c47b">{"cloudinaryImages":[{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/lpwat6i2mpwpgzkomc68","width":5332,"height":3552,"alt":"","publicId":"uploads/production/lpwat6i2mpwpgzkomc68"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/gxj4mi4kl0oxer7wdwgi","width":1000,"height":1000,"alt":"","publicId":"uploads/production/gxj4mi4kl0oxer7wdwgi"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/otke5vlkmrg6a5gp0hxl","width":1000,"height":1500,"alt":"","publicId":"uploads/production/otke5vlkmrg6a5gp0hxl"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/iqzgcwcu2zr0358ckf37","width":7952,"height":5304,"alt":"","publicId":"uploads/production/iqzgcwcu2zr0358ckf37"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/toiyerugdnkgji0dsfyh","width":5125,"height":3417,"alt":"","publicId":"uploads/production/toiyerugdnkgji0dsfyh"},{"src":"https://res.cloudinary.com/pinpointhq/image/upload/c_fit,f_auto,h_1080,q_auto,w_1920/v1/uploads/production/zrw1nruistevzollfwuu","width":5760,"height":3840,"alt":"","publicId":"uploads/production/zrw1nruistevzollfwuu"}],"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--centered-column ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-center">Benefits</h2>

            <div class="careers-block__trix external-panel text-center">We work hard, but we also know you have a family, friends, hobbies, and a life outside the office. That’s why we offer a great benefits package, not just a competitive salary.</div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--cards careers-block careers-cards-block careers-block--theme-secondary theme-secondary-background-color-ie-override">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


        <div class="careers-cards-block__cards">


            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/ptfqoqyxfntzoodx8gyp" /></noscript>
          <h3 class="careers-card-block__h3">41 days holiday</h3>
          <div class="careers-card-block__p "><div>This includes bank holidays and University closure days. Everyone needs a healthy, happy, and productive life. This means you'll need time to rest and recover.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/a29gqi9jxbmlmzgb55nd" /></noscript>
          <h3 class="careers-card-block__h3">Generous pension plans</h3>
          <div class="careers-card-block__p "><div>We've got you covered for the future. Work in the comfort of knowing that all your hard work is not only paying off now but also setting you up for the future.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/xtteafgr8zbnm8psxkik" /></noscript>
          <h3 class="careers-card-block__h3">Flexible working</h3>
          <div class="careers-card-block__p "><div>We know life is busy so, where we can, we support flexible working to ensure our teams are happy, productive and listened to.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/znf1rch7ya99ded9vsg8" /></noscript>
          <h3 class="careers-card-block__h3">Onsite nursery </h3>
          <div class="careers-card-block__p "><div>Reduce the morning stress by dropping the kids off at the onsite nursery. We've got you and your family covered.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/diujigcappmbapqoe5wo" /></noscript>
          <h3 class="careers-card-block__h3">Employee assistance programme </h3>
          <div class="careers-card-block__p "><div>We've teamed up with Telus Health to provide you with extra support when needed. Whether it is health, family, money, work or yourself, Telus Health is only a phone call away.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

            <section class="careers-cards-block__card col-md-1-3 careers-card-block careers-card-block--align-center careers-card-block--variant-normal">
              <section class="">


    <div class="frow frow--gutters-2x frow--gutters-sm-4x frow--gutters-md-8x">

      <div class="col-1-1 col-sm-order-2 col-order-2">

        <div class="careers-card-block__content">

          <img class="careers-card-block__icon cld-responsive" alt="" role="presentation" data-src="https://res.cloudinary.com/pinpointhq/image/upload/c_fit,dpr_auto,f_auto,h_80,q_auto,w_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /><noscript><img class="careers-card-block__icon" alt="" src="https://res.cloudinary.com/infuse-group/image/upload/f_auto,q_auto/v1/careers_sites_templates/compose/production/t31fhe8dltawq3vemgpk" /></noscript>
          <h3 class="careers-card-block__h3">A team that cares</h3>
          <div class="careers-card-block__p "><div>You’ll be joining a team of smart, capable, helpful people that want you to win, our students to win and our University and community to grow. Not to mention our team of care dogs who are on hand to put a smile on your face if needed.</div></div>
          

        </div>

      </div>


    </div>


</section>
</section>

        </div>


    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--text careers-block careers-block--header">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <div class="frow frow--column-start ">

        <div class="col-1-1 col-sm-6-7 col-md-4-5 col-lg-3-5">

            <h2 class="careers-block__h2 text-left">We asked our teams...</h2>

            <div class="careers-block__trix external-panel text-left"><div>"Beyond pay and benefits, what things make Bath Spa a great place to work?"</div></div>

        </div>

      </div>

    </div>

  </div>

</section>


    <section class="pinpoint-block pinpoint-block--carousel careers-block careers-carousel-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">


      <div id="External::Careerspage::Carousel-react-component-0096c723-525b-40f0-8387-d839af917983"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Careerspage::Carousel" data-dom-id="External::Careerspage::Carousel-react-component-0096c723-525b-40f0-8387-d839af917983">{"renderedBlocks":["\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The sense of community, my colleagues, the students, the campus, the general atmosphere of positivity and appreciation.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Sarah \n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;A culture that support equal access for staff and students.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Meg\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;Beautiful campus with the opportunity to learn new things from those around us. Also,\na good team working atmosphere where team members are willing to help and support each other. Cultivating a fun, happy and hard-working culture where everyone feels valued.\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Simon\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e","\u003csection class=\"pinpoint-block pinpoint-block--testimonial careers-block\"\u003e\n\n  \u003cdiv class=\"external-content-wrap\"\u003e\n\n    \u003cdiv class=\"careers-block__inner\"\u003e\n\n      \u003cdiv class=\"careers-testimonial-block\"\u003e\n\n        \n\n        \u003cdiv class=\"careers-testimonial-block__content\"\u003e\n\n\n            \u003cblockquote class=\"careers-testimonial-block__quotation\"\u003e\n              \u0026ldquo;The people are wonderful - their values are ones I agree with and try to live by.\n\u0026rdquo;\n            \u003c/blockquote\u003e\n\n\n          \u003ccite class=\"careers-testimonial-block__attribution theme-highlight-color-ie-override\"\u003e\n            Suman\n          \u003c/cite\u003e\n\n        \u003c/div\u003e\n\n      \u003c/div\u003e\n\n    \u003c/div\u003e\n\n  \u003c/div\u003e\n\n\u003c/section\u003e"],"autoplay":false,"autoplaySpeedMs":10000,"showDots":true,"infinite":true,"scrollAmount":1,"showAmount":1,"scrollSpeedMs":500,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


    </div>

</div>
</section>


    <section class="pinpoint-block pinpoint-block--jobs careers-block" id="js-careers-jobs-block">

  <div class="external-content-wrap">

    <div class="careers-block__inner">

      <h2 class="careers-block__h2 text-center">Current Opportunities</h2>

      <div class="careers-block__content pad-b-3">

        <div class="frow frow--gutters frow--gutters-md-2x frow--items-end">

          <div class="col-flex-grow-1">

            <form role="search">
              <button type="submit" disabled style="display: none" aria-hidden="true"></button>
              <div id="Shared::Search-react-component-424f8998-1000-4e2d-9ae8-532569d25900"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="Shared::Search" data-dom-id="Shared::Search-react-component-424f8998-1000-4e2d-9ae8-532569d25900">{"target":"external:jobs:index:5494","willUpdateUrl":true,"searchPlaceholderText":"Search...","featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      

            </form>

          </div>


            <div class="col-md-6-12">
              <div id="External::Filters-react-component-3eb00fbc-9ca8-4557-ae5f-1e637f375590"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Filters" data-dom-id="External::Filters-react-component-3eb00fbc-9ca8-4557-ae5f-1e637f375590">{"filters":[{"name":"location","attribute":"location_id","values":[],"items":[{"label":"Bath","value":10393},{"label":"Bath - Corsham Court","value":14961},{"label":"Bath - Locksbrook Campus","value":14959},{"label":"Bath - Newton Park","value":14958},{"label":"Bath - Newton Park \u0026 Locksbrook","value":14962},{"label":"Bath - Palace Yard Mews","value":17471},{"label":"Bath - Sion Hill Campus","value":14960},{"label":"Bath Spa University London","value":23470},{"label":"London - New City College ","value":14963},{"label":"Remote","value":27327},{"label":"The Studio - Palace Yard Mews","value":26635},{"label":"Various - Across SW England ","value":28564}],"translations":{"singleItem":"Location","pluralItems":"Locations","allItems":"All Locations"}},{"name":"department","attribute":"department_id","values":[],"items":[{"label":" Innovation and Knowledge Exchange Centre","value":37689},{"label":"Academic Planning","value":19086},{"label":"Art, Film \u0026 Media ","value":41507},{"label":"Bath Business school - London ","value":34431},{"label":"Bath School of Music and Performing Arts ","value":31904},{"label":"Bath Spa University London ","value":29962},{"label":"Business School","value":19085},{"label":"Careers and Employability","value":28533},{"label":"Catering ","value":34135},{"label":"Centre for Educational Partnerships ","value":38139},{"label":"Chancelry","value":25472},{"label":"Data \u0026 Insights Service","value":33104},{"label":"EAU","value":32064},{"label":"EAU Short Courses","value":29808},{"label":"Estates","value":25473},{"label":"Estates and Services","value":30675},{"label":"Estates/Security","value":30951},{"label":"External Affairs Unit","value":25474},{"label":"Facilities and Services","value":30050},{"label":"Finance","value":25475},{"label":"Future Students","value":31406},{"label":"Governance \u0026 Engagement ","value":35154},{"label":"Governance Legal \u0026 Compliance","value":25476},{"label":"HR","value":19087},{"label":"IT Services","value":25477},{"label":"Learning Innovation \u0026 Skills Unit /  Schools Technical Services","value":34216},{"label":"Learning, Innovation and Skills","value":36124},{"label":"Learning, Innovation and Skills: Academic Skills","value":28307},{"label":"Library and Learning Services","value":28326},{"label":"Marketing and Applicant Comms, Future Students ","value":29815},{"label":"Portfolio and Planning","value":30409},{"label":"Research \u0026 Enterprise","value":25478},{"label":"Research \u0026 Graduate Affairs","value":33220},{"label":"School Of Science","value":29645},{"label":"School of Art, Film \u0026 Media","value":36272},{"label":"School of Design","value":19088},{"label":"School of Education","value":25479},{"label":"School of Film \u0026 Arts","value":19084},{"label":"School of Music \u0026 Performing Arts","value":19083},{"label":"School of Science","value":29646},{"label":"School of Sciences","value":25480},{"label":"School of Writing Publishing \u0026 Humanities","value":25481},{"label":"School of Writing, Publishing and the Humanities","value":29246},{"label":"Strategic Projects \u0026 Delivery Unit","value":25482},{"label":"Strategic Projects and Change Unit","value":36037},{"label":"Student Accommodation ","value":35035},{"label":"Student Experience","value":25483},{"label":"Student Housing ","value":33411},{"label":"Student Wellbeing SErvices","value":31929},{"label":"Student Wellbeing Services ","value":28279},{"label":"Student and Registry Services","value":29262},{"label":"Student wellbeing Services","value":31930},{"label":"Technical Services","value":30746},{"label":"Wellbeing \u0026 Disability","value":30147},{"label":"Writing, Publishing \u0026 Humanities ","value":29781}],"translations":{"singleItem":"Department","pluralItems":"Departments","allItems":"All Departments"}}],"isUrlFilterable":true,"target":"external:jobs:index:5494","willUpdateUrl":true,"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      


            </div>


        </div>

      </div>

    </div>

  </div>


  <div id="External::Jobs-react-component-06a42fbf-b31f-4292-822f-7291b72580d5"></div>
      <script type="application/json" class="js-react-on-rails-component" data-component-name="External::Jobs" data-dom-id="External::Jobs-react-component-06a42fbf-b31f-4292-822f-7291b72580d5">{"additionalColumns":[],"url":"/postings.json","target":"external:jobs:index:5494","translations":{"job_title":"Job Title","department":"Department","division":"Division","requisition_id":"Requisition ID","structure_custom_group_one":"Custom","location":"Location","employment_type":"Employment Type","no_positions":"There are currently no positions advertised.","no_opportunities":"There are currently no opportunities based on your filters. Please try again, or register your interest.","workplace_type":"Workplace type"},"structures":[{"key":"location","keyPlural":"locations","name":"Location","namePlural":"Locations","nameAccessor":"locationName","columnVisibilityAccessor":"locationsColumnVisible"},{"key":"department","keyPlural":"departments","name":"Department","namePlural":"Departments","nameAccessor":"departmentName","columnVisibilityAccessor":"departmentsColumnVisible"}],"visible_columns":{"employment_type_column_visible":true,"locations_column_visible":true,"departments_column_visible":true,"divisions_column_visible":true,"requisition_id_column_visible":null,"structure_custom_group_ones_column_visible":true,"workplace_type_column_visible":null},"showPagination":false,"pageSize":null,"featureFlags":{"job_templates":"enabled"},"companySettings":{"edit_offer_before_send":true,"advanced_search":true,"facebook_advert":false,"bulk_download":false,"move_to_hired_on_offer_acceptance":true,"bulk_email_job_seekers":false,"workflow_automation":true,"cronofy_enterprise_connect":true,"job_requisition_management":true,"essential_cookies_only":false,"use_company_from_address":true,"semi_private_comments":false,"additional_statuses":true,"multiple_company_themes":false,"strict_ofccp_compliance":false,"grouped_jobs":false,"move_to_any_job":true,"remove_logo_from_email_template":false,"candidate_job_preferences":false,"automatically_reject_referrals":false,"indeed_feed_stages":false,"variable_sign_off_signatories":true,"react_select_on_external_jobs":false,"monitor_with_rum":false,"restricted_cronofy_oauth_scope":false,"application_national_identifiers":false,"allow_inactive_structures":false,"visible_other_applications":false,"allow_editing_job_requisition_fields":true,"two_column_sidebar":false,"multiple_job_postings":false,"max_applications":false,"group_interviews":false,"create_requisitions_for_existing_jobs":true,"team_rejection_notification":false,"send_pdf_copy_of_application":false,"disable_indeed_feed":false,"vonq_v2":true,"redirect_to_custom_subdomain":true,"add_cc_and_bcc_to_email":true,"allow_creating_company_teams":false,"manually_send_offers":false,"private_calendar_events":true,"candidate_details_in_offer_header":false,"show_date_in_offer_header":true,"show_job_seekers_in_all_candidates":false,"talent_pipeline":true,"anonymous_screening":true,"candidate_surveys":true,"task_management":true,"offer_management":true,"referral_management":true,"advanced_reporting":true,"allow_cover_letters":true,"location_city_state":false,"dei_reports":true,"accessible_date_and_phone":false,"enable_redaction":true,"internship_programme":false,"document_templates_on_stage":true,"stage_visibilities":true,"onboarding_v2":false,"limit_onboarding_to_hired_candidates":false,"personal_details_auto_update":true,"group_assessments":true,"enforce_all_offer_fields_required":false,"resume_parsing":true,"custom_job_posting_locations":false,"offer_splitting":false,"indeed_locale_url":false,"download_pdf_application":true,"workflow_automation_v2":false,"disable_cookie_dialog":false,"linkedin_job_postings":false,"talent_pipeline_v2":true,"require_headcount":false,"onboarding_v1":true,"skills":true,"careers_site_builder_v2":false,"extra_monitoring_for_automations":false,"questionnaires":false,"candidate_policy_plucking":false,"stage_groups":false,"docusign_logging":false,"enable_cronofy_event_deletion_tracking":false},"enabledLocaleKeys":["en"],"userRoles":null,"onboardingSettings":{"isOnboardingEnabled":true}}</script>
      



</section>



</main>


  </div>

    <footer class="external-footer theme-secondary-background-color-ie-override" id="external-content-footer">

  <div class="external-content-wrap">


    <div class="external-footer__content">

      <div class="frow frow--justify-between frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-3x">

        <div>

          <div class="frow frow--items-sm-center frow--direction-column frow--row-sm frow--gutters-2x">


              <a class="external-footer__link" target="_blank" href="https://www.bathspa.ac.uk/">

                Bath Spa University <i class="fas fa-external-link-alt mar-l-1"></i>

</a>

            <a class="external-footer__link" target="_blank" href="/themes/2198/privacy_policy">
              Privacy Policy
</a>
              <a class='external-footer__link' data-cc="c-settings" aria-label="View cookie settings" tabindex="0" role="button">
                Cookies
              </a>

            <div class="frow frow--gutters frow--items-center">
              <a class="external-footer__link" href="https://www.facebook.com/bath.spa.university" target="_blank" title="Bath Spa University&#39;s Facebook page." style="margin-right: 5px;"><i class="fab fa-facebook fa-lg" style="color: #3B5998"></i></a>
              
              
              
              <a class="external-footer__link" href="https://www.instagram.com/bathspauni" target="_blank" title="Bath Spa University&#39;s Instagram page." style="margin-right: 5px;"><img alt="Bath Spa University instagram" src="https://d2n5ied94mazop.cloudfront.net/packs/static/logos/external/instagram_logo-5139d56ff0927cddd11f.svg" /></a>
              
            </div>

          </div>

        </div>

        <div>

          <a class="external-footer__link" target="_blank" href="https://www.pinpointhq.com">Powered by Pinpoint</a>

        </div>

      </div>

    </div>

  </div>

  </div>

</footer>


  







    <script nonce="5b08b3e58a1af308e956005a8a13b467">
  // Ensures that the stuff in the iframe doesn't take focus
  setTimeout(() => {
    var frames = document.getElementsByTagName("iframe");
    for (i = 0; i < frames.length; ++i) {
      frames[i].setAttribute("tabindex", "-1");
    }
  }, 1000)
</script>


</body>

+  recorded_at: Tue, 30 Jul 2024 16:28:48 GMT
 - request:
     method: get
     uri: https://bathspa.pinpointhq.com/postings.json
@@ -163,7 +163,7 @@ http_interactions:
       Server:
       - nginx
       Date:
-      - Mon, 29 Jul 2024 09:07:01 GMT
+      - Tue, 30 Jul 2024 16:28:48 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -187,22 +187,22 @@ http_interactions:
       Content-Security-Policy-Report-Only:
       - 'default-src ''self'' https:; font-src ''self'' https: data:; img-src ''self''
         https: data:; object-src ''none''; media-src ''self'' https: blob:; script-src
-        ''self'' https: ''strict-dynamic'' ''nonce-3cbb8b8ee1caf8e6f6b457fa8f15cedd'';
+        ''self'' https: ''strict-dynamic'' ''nonce-54def27018a1f48e73d3d7195ae5468c'';
         style-src ''self'' https: ''unsafe-inline''; connect-src ''self'' https: wss:;
         base-uri ''none''; report-uri /csp_violation_reports'
       Set-Cookie:
-      - LSW_WEB=LSW_WEB4; path=/
-      - _pinpoint_session=c9SGM5W0ptT1q7mlZ0NFQei7ki6BCGi%2Fm1%2Bzm9lTq3%2BYfN6syCW33OzPKTcwwOR3lFobxLQqNEUd4KBO4PTIAIFg%2BZDPTpznqAiJLcVltIFg3WOb2eZI0FNCP%2F%2ByHwD4Q65hU8S58BA0YPoLzjMpG8Zr72uCZegLTZ7tZNvL1G7XV4ctMB%2Fp2GqgEVzh7c1scuR6CmsuQWlYY5WnEaQLm8KwCxpEgnwT7iDgls9%2FBq2oxNIU0weS7QrUfIolxkgE35n1jKNtl90%2FHNdpHiKoX7DbWjTgJQQv3te%2BJTpjNfgtWAU%3D--8UmlyIw%2BZEEHKYBe--%2BRUwT8k3mW2rbxOc9WX%2BNA%3D%3D;
-        domain=.pinpointhq.com; path=/; expires=Mon, 05 Aug 2024 09:07:01 GMT; secure;
+      - LSW_WEB=LSW_WEB6; path=/
+      - _pinpoint_session=wTfI37Fd2RRHYTObyHLnpuohJq9br2Mr4fsWTz5UfkwsjHKZB7nNN2FhS%2BUWTbs3YZLTx9Ze5CaHIJzZThyc3r1bSegUWlWbyjBE0IWRqgLKgUwzjzC17jGC%2FV5%2B3hTOpJQ2I26IPIp1o3v53RYLEmiw%2F%2BBJdXEStquwP4kEMZsNLJRgr0dK3Q9X88KVnM0mYiSFNXYKpwhaEe%2BpzWmXz3SCBWZi7%2BRnS36WKQFjv5nRXxjr8XNmAJLZDLbcqb0OT5FdKnOczJLmXmBhVkf0XQhmcvTG5k0ZuCWdhO%2FySMU1ubI%3D--a1dcxV4zq4FZQnDG--r2G2uO1uJsP%2BZHfTyc5%2BHA%3D%3D;
+        domain=.pinpointhq.com; path=/; expires=Tue, 06 Aug 2024 16:28:48 GMT; secure;
         HttpOnly; SameSite=None
-      - ahoy_visit=d97cb0b4-f6b5-4c1e-b315-fc460207c111; path=/; expires=Mon, 29 Jul
-        2024 13:07:01 GMT; secure
-      - ahoy_visitor=f26bcb44-0abf-4cea-88d7-b28fb6058abc; path=/; expires=Wed, 29
-        Jul 2026 09:07:01 GMT; secure
+      - ahoy_visit=9aba008e-6a01-42bc-bbf5-02ceac0c650c; path=/; expires=Tue, 30 Jul
+        2024 20:28:48 GMT; secure
+      - ahoy_visitor=618d01b2-696d-4fd4-bfd3-b18c22de8606; path=/; expires=Thu, 30
+        Jul 2026 16:28:48 GMT; secure
       X-Request-Id:
-      - 2e5f0f65-bb7f-4472-853b-7bac8d5a02ff
+      - 7983602f-c0f6-42d9-b15b-dc37bcc4eb5f
       X-Runtime:
-      - '0.284896'
+      - '0.202814'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Vary:
@@ -213,10 +213,10 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         {"data":[{"id":"194729","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eInterview Dates - Monday 16th \u0026amp; Tuesday 17th September 2024 \u003cbr\u003e\u003cbr\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003c/strong\u003e\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003e\u003cstrong\u003ea.carr2@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-26T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking an experienced Early Years, primary and/or secondary age phase practitioner to take on the role of teacher and tutor for the academic assignments of BSU’s highly regarded SCITT PGCE programme.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eTeaching takes place both in-person at our SCITTs across England and online, with much of the course delivered virtually.\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University’s School of Education provides the SCITT PGCE award to a growing number of SCITT providers, working with 13 partners from September 2024.\u0026nbsp; Whilst the SCITT provides the training that leads to a recommendation for QTS, this role relates to Bath Spa University’s provision of the academic award of PGCE. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn order to support trainees in understanding the value of critical awareness of professional practice at Masters level, through the completion of academic assignments, the post holder will deliver: SCITT assignment launches, seminars to groups of trainees, individual tutorials, online support and assignment assessment. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe work of the SCITT PGCE programme is delivered at a range of sites across England.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have QTS, a first degree, a higher degree (or working towards a higher degree) and will be confident in teaching at Masters level and working with trainee teachers.\u0026nbsp; Experience of working in a school or other educational institution is essential.\u0026nbsp; Experience in the Early Years, primary and/or secondary age phase is essential, but you will also have knowledge and understanding of learning pedagogy and current thinking in wider educational issues. \u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent communication skills, a collaborative and enthusiastic approach to teacher education and be a committed team player.\u0026nbsp; You will be a confident communicator and user of IT, particularly online learning environments.\u0026nbsp; You must be a flexible thinker and be willing to engage in the development of this area of teacher education.\u003cbr\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003ea.carr2@bathspa.ac.uk\u003c/a\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow for School-Centred Initial Teacher Training (SCITT) PGCE Programme","url":"https://bathspa.pinpointhq.com/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","path":"/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"213031","requisition_id":"282/23/24","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"196971","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 7 - £37,099 - £41,732 per annum\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eInterview Date - W/C 12th August\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-04T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eThis is an exciting opportunity to join us as Strategic Projects \u0026amp; Change Manager at Bath Spa University. You will be involved in a wide range of strategic activities and will play a key role in managing and facilitating change projects, new ways of working, and process improvements.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs Strategic Projects \u0026amp; Change Manager you will manage project initiation phases, oversee large-scale programs, and ensure effective end-to-end project management. \u003cbr\u003e\u003cbr\u003eYou will work closely with senior leadership, project sponsors, and teams to meet project requirements, timelines, and outputs, while maintaining robust communication channels. \u003cbr\u003e\u003cbr\u003eYour role will involve coordinating project activities, supporting senior oversight groups, tracking project metrics, and developing best practice project management collateral. \u003cbr\u003e\u003cbr\u003eAdditionally, you will facilitate forums for cross-university collaboration, build strong networks across academic and professional services teams, and contribute to staff development and your own professional growth.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent stakeholder management skills with a demonstrable ability to communicate effectively with a diverse audience will be key. \u003cbr\u003e\u003cbr\u003eYou will have a structured approach to producing accurate project documentation and reporting, be self-motivated, and experienced at working at a strategic level across a varied workload.\u003cbr\u003e\u003cbr\u003eIn addition, you will be flexible, calm under pressure and will have excellent organisational and prioritisation skills\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Strategic Projects \u0026 Change Manager","url":"https://bathspa.pinpointhq.com/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","path":"/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"215223","requisition_id":"348/23/24","department":{"id":"36037","name":"Strategic Projects and Change Unit"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"197279","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eFull Time Fixed Term Contract initially for 12 months, although can be shortened or lengthened based on the maternity leave\u003cbr\u003e\u003cbr\u003eInterview Date - 14th August 2024\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking to recruit Teaching Fellows in Psychology to join our dedicated and committed team in Psychology.\u003cbr\u003e\u003cbr\u003e(Please note that the role is initially for 12 months, although can be shortened or lengthened based on the maternity leave)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will be the key support to undergraduate teaching across our programmes within Psychology. You will design and deliver teaching content across a range of modules at Levels 4 to 6 in Psychology Programmes, with a particular focus on Forensic Psychology, as well as contributing to curriculum planning and development, and engaging in research or scholarly activity in Psychology.\u003cbr\u003e\u003cbr\u003eYou will undertake teaching within Psychology in the form of lectures, practical sessions, seminars, discussions groups and tutorials as appropriate, whilst supporting undergraduate students individually and online.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn addition, you will help mark assessments associated with the teaching and will attend assessment and examination meetings as required.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking a flexible and positive individual who will be able to teach a broad range of Psychology at all undergraduate levels, with a particular focus on Forensic Psychology (though all areas of expertise are welcome) and have a BPS-Accredited undergraduate degree.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will have experience of teaching all aspects of general Psychology, as well as prior experience of different teaching methods and/or experience of university level teaching. As an excellent communicator, you will work successfully as part of a small team, whilst showing the ability to manage your own time with limited supervision.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role is available on a job-share basis that would enable you to complete postgraduate studies (e.g., a PhD) alongside the role.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor informal enquiries about the role, please contact Prof Peter Hills; \u003c/strong\u003e\u003ca href=\"mailto:p.hills@bathspa.ac.uk\"\u003e\u003cstrong\u003ep.hills@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow in Psychology (Maternity Cover)","url":"https://bathspa.pinpointhq.com/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","path":"/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"215498","requisition_id":"344/23/24","department":{"id":"25480","name":"School of Sciences"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198167","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a part time role, 28 hours per week.\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 6 - £24,457 - £27,261 per annum, pro rata £32,332-£36,024\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eSome evening and weekend working during term time will be required.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£24,457 - £27,261 per annum, pro rata £32,332-£36,024 ","compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking an dedicated Technical Demonstrator (moving image)\u003cstrong\u003e \u003c/strong\u003eto be responsible for the delivery of specialist technical skills demonstrations to either groups of students or one-to-one support to individuals here at Bath Spa University\u003cbr\u003e(This is a part time role, 28 hours per week)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"part_time","employment_type_text":"Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role of a Technical Demonstrator combines technical knowledge and innovative thinking with the design and delivery of hardware and software demonstrations to students. Within the role you will be responsible for ensuring the maintenance of specialist equipment is carried out within own area of work and that health and safety standards are complied with. This role will be based around the delivery of training and demonstration of moving image capture, motion graphics generation, editing and gallery presentation. It will be located at the Locksbrook Rd campus mainly working with students enrolled on courses within the Schools of Art, Film and Media and the School of Design.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eAs Technical Demonstrator you will demonstrate complex technical techniques to students from various programs, support individual and group student work, and develop and run workshops on the use of our facilities. You will be responsible for preparing resources and equipment, supervising students' project work, and ensuring health and safety compliance within the workspace. Additionally, you will conduct risk assessments, maintain equipment, and stay updated with new technologies and contemporary practices in your field. You may also advise on future resource requirements and supervise a small team of technical staff.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be a qualified Workshop and Laboratory Technician with an NVQ4, NEBSS, or degree in a relevant practical subject, or significant professional experience in a specialist area. You will have experience in demonstration or training, supervisory skills, and expertise in video capture, motion graphics, animation, and gallery presentation of moving images.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou should demonstrate a proactive approach to maintenance, development, and safety, possess excellent interpersonal, written, and oral communication skills, and have strong ICT capabilities.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe role requires the ability to plan and organise work, manage resources, liaise with staff, departments, and external agencies, use initiative and problem-solving skills, make decisions, and work under pressure to tight deadlines. Flexibility, adaptability, and a positive approach to change are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Technical Demonstrator (Moving Image)","url":"https://bathspa.pinpointhq.com/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","path":"/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"216378","requisition_id":"347/23/24","department":{"id":"30746","name":"Technical Services"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"198471","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the Games Development and Creative Computing (Games) courses at Bath Spa University.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of games design and development.\u0026nbsp;\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institution in games development or similar Creative Computing subjects. We expect that as a games and creative technology specialist, you will be actively engaged in related practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will ideally have additional industry and/or teaching experience using modern game engines such Unity3D and Unreal, and some knowledge of others. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience in a game production role is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer – Games Development","url":"https://bathspa.pinpointhq.com/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","path":"/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216674","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198483","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the BSc (HONS) Computing course at Bath Spa University. \u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of Computing.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institute in Computing subjects. We expect that as a Computing specialist, you will be actively engaged in computing practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have industry and/or teaching experience within one or more of the following areas: OO software development using C++, software engineering, and business analysis. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience developing creative and entertainment software is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer - Computing","url":"https://bathspa.pinpointhq.com/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","path":"/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216686","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198822","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eWe encourage applications from disabled people and can provide reasonable adjustments, so please let us know if there is anything we can do to make applying for this role more accessible for you. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eSalary: Grade 5 - £27,979 to £31,396 (per annum), £5,595.80 to £6,279.20 (pro-rata)\u003cbr\u003e\u003cbr\u003eThis is a 0.2 FTE part-time, one year fixed-term role.\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£27,979 - £31,396 / year","compensation_minimum":27979.0,"compensation_maximum":31396.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently\u003cstrong\u003e \u003c/strong\u003eseeking to appoint a Research Assistant to support the creation and development of a disability hub which aims to bring together and disseminate We Are The People research to the South West. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe Are The People (WATP) is a small research team of disabled academics and non-disabled allies engaged in disability research and disability activism. We've been awarded a five-year, £1million grant from the \u003ca href=\"https://wellcome.org/\"\u003e\u003cstrong\u003eWellcome Trust\u003c/strong\u003e\u003c/a\u003e to explore issues which affect disabled people in South West England.\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_part_time","employment_type_text":"Fixed Term - Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role involves developing an understanding of ongoing research by Disabled People’s Organisations (DPOs), creating a disability training programme led by disabled individuals, and organizing events to showcase findings. You will ensure the accessible dissemination of research results, investigate collaborative opportunities with DPOs, and build relationships with community contacts for future funding.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eKey responsibilities include providing guidance to community partners, contributing to meetings, adhering to Health and Safety guidelines, and developing research methods within the programme framework.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be passionate about disability equality and hold a good first degree in a relevant discipline such as Disability Studies, Psychology, Social Science, Arts, etc. You will also have demonstrable experience of working in a co-productive way with project partners, contributing to a community, charity or research environment.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will also show a demonstrable understanding of the sensitivities of working with underrepresented groups, and to respond to potential barriers in a compassionate way. In addition, you will be an excellent problem solver, flexible, adaptable and a committed team player. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact the team at: \u003ca href=\"mailto:WeAreThePeople@bathspa.ac.uk\"\u003eWeAreThePeople@bathspa.ac.uk\u003c/a\u003e \u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Research Assistant - We Are The People project","url":"https://bathspa.pinpointhq.com/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","path":"/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217032","requisition_id":"360_23_24  ","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199360","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis role is a one year fixed-term contact.\u003cbr\u003e\u003cbr\u003eSalary: Grade 8s, £42,978 to £44,263\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £44,263 / year","compensation_minimum":42978.0,"compensation_maximum":44263.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-11T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University is seeking a dynamic and innovative Head of Recruitment to lead and deliver cutting-edge resourcing solutions.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role focuses on developing sustainable staff recruitment strategies, optimizing our employer value proposition (EVP), and enhancing our recruitment branding across all platforms. (This is a 1 year Fixed Term Contract)\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will oversee a smooth and efficient recruitment process, enhancing both the candidate and hiring manager experience and will lead the recruitment team, providing expert guidance and support. Collaborating with senior managers, you will understand strategic recruitment needs and determine the best resourcing strategies. Proactive sourcing of hard-to-fill or senior roles through headhunting, microsites, and video content will be essential.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eSetting and reviewing key performance indicators (KPIs) will be a critical part of the role, ensuring effective recruitment processes and annual reporting on trends. You will embed our EVP through recruitment marketing techniques aligned with the University's values and culture and will build BSU’s presence on social media to increase engagement. Implementing initiatives to improve workforce diversity and ensuring recruitment efforts align with the University’s Equality, Diversity, and Inclusion (ED\u0026amp;I) Strategy is vital. Inclusive recruitment practices must be maintained throughout the candidate journey, and you will influence line managers to prioritise talent diversity.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eEstablishing and managing a talent pool process for future vacancies will be part of your remit, as well as building external networks to stay updated on recruitment trends and advising the University accordingly.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have proven expertise in employee resourcing strategies and recruitment processes, strong leadership and team management skills, and experience in developing and implementing EVP.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eProficiency in utilising social media for recruitment, a commitment to diversity and inclusion in the workplace, and excellent communication and relationship-building skills are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Head of Recruitment","url":"https://bathspa.pinpointhq.com/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","path":"/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217566","requisition_id":"254-23-24","department":{"id":"19087","name":"HR"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199810","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eTemporary, fixed term Semester/Trimester one and two 2024 -2025. Part Time Hours to be agreed.\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eGeneral teaching commences week beginning 30th September 2024 but module development will before these date. Our 2024/5 term dates can be found at https://www.bathspa.ac.uk/about-us/term-dates/\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are looking for talented Associate Lecturers in Law to join our collegial team, contributing to teaching and development of law modules on a part time basis at various times through the 2024/2025 academic year.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Associate Lecturer posts require lecturing, taking seminar groups, assessment and working as part of a team of tutors.\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAt Bath Spa University we work with one clear vision: to be a leading university in creativity, culture and enterprise. And we place collaboration at the heart of everything we do. With ever growing student numbers, we make sure our people are engaged and empowered by blending digital technologies, international perspectives, work-oriented connections and inspirational teaching. Together we’re on a journey to transform our students’ lives. And it starts with people like you.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eAbout Bath Business School\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eBath Business School is set within a beautiful countryside location, close to the world heritage city of Bath. Our staff and students are ethically aware, socially engaged and globally connected through our links to research, and professional and creative industry networks.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eOur Law Degree\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eOur new LLB Law degree has been designed to be unique and incorporates a range of business skills and optional modules whilst encompassing the foundations of legal knowledge found in SQE 1 and many elements of SQE 2.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Bath Spa LLB is at the cutting edge of legal education. Our LLB offers a range of authentic assessments, the offer of multiple placement opportunities including a placement year, as well as the opportunity of undertaking the Law Clinic module for final year students.\u0026nbsp; Our Law Clinic is a result of an impressive joint venture between Bath Spa University, Stone King LLP and the Citizens Advice Bureau BANES.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe believe in giving our students a high-quality educational experience, exceptional opportunities to become highly employable as well as unrivalled pastoral care.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor further information contact Steven Goulton, Law Course Director, Bath Business School, \u003c/strong\u003e\u003ca href=\"mailto:s.goulton@bathspa.ac.uk\"\u003e\u003cstrong\u003es.goulton@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","key_responsibilities_header":"About Us.","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eIdeally you will have expertise in one or more of the following areas (please see below for further information on Associate Lecturer role specifics):\u003c/div\u003e\u003cul\u003e\u003cli\u003e\u003c!--block--\u003eTort Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmployment Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eBusiness Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eDissertation supervision\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEquity and trusts\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eProperty Law\u0026nbsp;\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmerging technologies – AI, cyberlaw etc\u003c/li\u003e\u003c/ul\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer in Law","url":"https://bathspa.pinpointhq.com/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","path":"/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218013","requisition_id":"","department":{"id":"19085","name":"Business School"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199873","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - 11th \u0026amp; 12th September 2024\u003cbr\u003e\u003cbr\u003ePlease email Clara Giaminardi \u003c/strong\u003e\u003ca href=\"mailto:c.giaminardi@bathspa.ac.uk\"\u003e\u003cstrong\u003ec.giaminardi@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e directly for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eOur BA (Hons) Fashion Photography course is looking for associate lecturers with in-depth knowledge and/or industry experience in the areas of fashion photography, fashion styling and fashion communication to deliver teaching on our level 4 and level 5 modules.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs an associate lecturer on BA (Hons) Fasion Photography, your primary responsibility will be delivering engaging and high quality teaching in the appropriate subject area. This includes developing and undertaking in-person lectures, practical workshops, seminars and tutorials to support our level 4 and level 5 students in the development of their work.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eIn the role, you will also be marking and assessing module work, providing constructive feedback and attending assessment meetings where required to ensure fair and consistent grading. You will also be expected to work closely with module staff and support on some administrative tasks, ensuring the smooth running of the module. This includes engaging with existing virtual learning environments to ensure cohesive dissemination of module materials and student communication across the course.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eThe role requires an in-depth subject knowledge and/or industry expertise in the areas of fashion photography, fashion styling and/or fashion communication. You will have excellent communication and interpersonal skills and will be able to translate key skills and concepts into appropriate language and tasks for level 4 and level 5 students. A solid understanding of contemporary trends and industry practices is essential to ensure high quality of teaching for students going into future industry.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003ePrior experience teaching undergraduate students in these areas is desirable. You will have excellent organisational and time management skills, and be able to work successfully as part of a small team. Alongside solid IT skills, expertise in industry specific digital tools such as the Adobe Creative Suite is beneficial.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer, BA (Hons) Fashion Photography","url":"https://bathspa.pinpointhq.com/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","path":"/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218077","requisition_id":"","department":{"id":"36272","name":"School of Art, Film \u0026 Media"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"200623","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a Fixed Term Contract until November 2024.\u003cbr\u003e\u003cbr\u003eSalary: Grade 2, £23,152\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u003c/strong\u003e\u003cbr\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£23,152 / year","compensation_minimum":23152.0,"compensation_maximum":23152.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-05T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eExciting opportunity for a reliable and dedicated individual to join our elite Facilities and Services team in helping maintain a clean and safe environment on our Sion Hill Campus. (This is a Fixed Term Contract until November 2024)\u003cbr\u003e\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eOur team prides ourselves on our positive ‘can do’ approach towards supporting our students, staff and visitors.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eAs a valued member of our vibrant team, you'll be the unsung hero behind the scenes, transforming every corner of our campus into a sparkling haven of knowledge and innovation at the same time as providing excellent customer service.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eEmbrace the excitement of a dynamic environment where no two days are alike.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eDue to the University’s locations, having your own transport is recommended, however, there is the option of public transport (this is limited during the summer months).\u003cbr\u003e\u0026nbsp;\u003cbr\u003eCleaning experience is beneficial but what we’re looking for most is reliability, attention to detail and a willingness to learn.\u003cbr\u003e\u0026nbsp;\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Full Time Cleaner (Fixed Term Contract)","url":"https://bathspa.pinpointhq.com/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","path":"/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218783","requisition_id":"","department":{"id":"25473","name":"Estates"},"division":null,"structure_custom_group_one":null},"location":{"id":"14960","city":"Bath","name":"Bath - Sion Hill Campus","province":"Bath"}}]}
-  recorded_at: Mon, 29 Jul 2024 09:07:01 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:48 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.bathspa.ac.uk/"]}],"limit":1}'
@@ -239,9 +239,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:07:02 GMT
+      - Tue, 30 Jul 2024 16:28:49 GMT
       Etag:
-      - W/"1722244022141"
+      - W/"1722356929582"
       Server:
       - openresty
       X-Cb-Engine:
@@ -253,11 +253,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '4'
+      - '5'
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '15'
+      - '14'
       Content-Length:
       - '615'
       Connection:
@@ -268,8 +268,8 @@ http_interactions:
         Spa University","identifier":{"permalink":"bath-spa-university-2","image_id":"v1488530438/cej4b9ng1amolmbwoqp0.png","uuid":"f221c78f-54eb-1f68-967d-87d6046d43e5","entity_def_id":"organization","value":"Bath
         Spa University"},"linkedin":{"value":"https://www.linkedin.com/company/bath-spa-university"},"short_description":"Bath
         Spa offers undergraduate and postgraduate study and research opportunities
-        with a focus on creativity, culture and enterprise.","rank_org":453560,"website_url":"https://www.bathspa.ac.uk/"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:07:02 GMT
+        with a focus on creativity, culture and enterprise.","rank_org":452146,"website_url":"https://www.bathspa.ac.uk/"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:49 GMT
 - request:
     method: get
     uri: https://bathspa.pinpointhq.com/postings.json
@@ -291,7 +291,7 @@ http_interactions:
       Server:
       - nginx
       Date:
-      - Mon, 29 Jul 2024 09:07:02 GMT
+      - Tue, 30 Jul 2024 16:28:49 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -315,22 +315,22 @@ http_interactions:
       Content-Security-Policy-Report-Only:
       - 'default-src ''self'' https:; font-src ''self'' https: data:; img-src ''self''
         https: data:; object-src ''none''; media-src ''self'' https: blob:; script-src
-        ''self'' https: ''strict-dynamic'' ''nonce-1bcaee248edd62709c8fe49ddfc553ea'';
+        ''self'' https: ''strict-dynamic'' ''nonce-ea3ccd67f57aab8a193969ec3d44c937'';
         style-src ''self'' https: ''unsafe-inline''; connect-src ''self'' https: wss:;
         base-uri ''none''; report-uri /csp_violation_reports'
       Set-Cookie:
-      - LSW_WEB=LSW_WEB7; path=/
-      - _pinpoint_session=DIsOJeY2evTNt1UbX6zFUUqKlB1CWYnr0wlIFhJspI98ADkAp9A19MFOPUiuC%2FwE1SUGjn1KjnHNvkYGPeoViMI8cRRNGs9OJD5nN1NjMQPzFiJsqSmRxV3aqXb5pdN010VeUT6toWONeFolo6FqyZqpVkB4ciH7xHXErihxgTWH9q8FFD4oWi1AGQryj7fU8czHm1oKWtpsMEVKEtKfpKJqs5MZGKt5Jw%2BG15J2FMeqW27uXzHjaJmH2HsoXsT5T7%2B14R39E1IOcHqppBE24Bog9CKHDvaj7NoafORwQPWhVNY%3D--VtmhmaOX7bxN8DC2--RlamvoRP1%2Fkb2XdFJtnCkQ%3D%3D;
-        domain=.pinpointhq.com; path=/; expires=Mon, 05 Aug 2024 09:07:02 GMT; secure;
+      - LSW_WEB=LSW_WEB5; path=/
+      - _pinpoint_session=qGJhmsvvfQ95w0OJix5w3WLRKLwcxRAz%2FrZH45xu6PJu%2FTxR3Lg7Ijn4sljg4%2FF4CXnzvsuTL1d9HsPL0KNIPVz0eihMszRajzdlxMPiB0r4iTPmN%2F%2Bxap%2FLCxQREt7iRPqBJnOKz5M%2BOuQhtDKYodBZ1GufC2TsiYwmqseoSoZ0W66BhcvzxSkKAJf%2BEJGhLgKHnzBh9ee9sCSt42p7UEf%2B4bNe%2FasKpnXoz99CmGKkYgNM5GZGtn72CeB8C1mCC%2BtaMmoMR%2FzExZL%2FE2EI0Yhv9zM9j2cnZhDvLMT2SxygsG0%3D--5gYh7Fq1faGOAy4n--%2BnZPVEYGw6O2R3IJVdSGag%3D%3D;
+        domain=.pinpointhq.com; path=/; expires=Tue, 06 Aug 2024 16:28:49 GMT; secure;
         HttpOnly; SameSite=None
-      - ahoy_visit=6c07b52f-edc5-440d-8e8c-2b1cf33fbb55; path=/; expires=Mon, 29 Jul
-        2024 13:07:02 GMT; secure
-      - ahoy_visitor=54699c82-c373-408f-ba74-e72e1233e947; path=/; expires=Wed, 29
-        Jul 2026 09:07:02 GMT; secure
+      - ahoy_visit=4ffbce46-394b-4011-8559-1f1cbeabd2ff; path=/; expires=Tue, 30 Jul
+        2024 20:28:49 GMT; secure
+      - ahoy_visitor=c031183d-e86b-4431-87f8-ac7ed6341c58; path=/; expires=Thu, 30
+        Jul 2026 16:28:49 GMT; secure
       X-Request-Id:
-      - af79d5b7-58ef-4af2-aa85-dc06f0aae798
+      - b848d6f7-d1fd-400a-adfa-b474612d5d94
       X-Runtime:
-      - '0.351253'
+      - '0.183943'
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Vary:
@@ -341,7 +341,7 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         {"data":[{"id":"194729","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eInterview Dates - Monday 16th \u0026amp; Tuesday 17th September 2024 \u003cbr\u003e\u003cbr\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003c/strong\u003e\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003e\u003cstrong\u003ea.carr2@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-26T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking an experienced Early Years, primary and/or secondary age phase practitioner to take on the role of teacher and tutor for the academic assignments of BSU’s highly regarded SCITT PGCE programme.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eTeaching takes place both in-person at our SCITTs across England and online, with much of the course delivered virtually.\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University’s School of Education provides the SCITT PGCE award to a growing number of SCITT providers, working with 13 partners from September 2024.\u0026nbsp; Whilst the SCITT provides the training that leads to a recommendation for QTS, this role relates to Bath Spa University’s provision of the academic award of PGCE. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn order to support trainees in understanding the value of critical awareness of professional practice at Masters level, through the completion of academic assignments, the post holder will deliver: SCITT assignment launches, seminars to groups of trainees, individual tutorials, online support and assignment assessment. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe work of the SCITT PGCE programme is delivered at a range of sites across England.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have QTS, a first degree, a higher degree (or working towards a higher degree) and will be confident in teaching at Masters level and working with trainee teachers.\u0026nbsp; Experience of working in a school or other educational institution is essential.\u0026nbsp; Experience in the Early Years, primary and/or secondary age phase is essential, but you will also have knowledge and understanding of learning pedagogy and current thinking in wider educational issues. \u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent communication skills, a collaborative and enthusiastic approach to teacher education and be a committed team player.\u0026nbsp; You will be a confident communicator and user of IT, particularly online learning environments.\u0026nbsp; You must be a flexible thinker and be willing to engage in the development of this area of teacher education.\u003cbr\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact Andrew Carr, SCITT PGCE Programme Director (\u003ca href=\"mailto:a.carr2@bathspa.ac.uk\"\u003ea.carr2@bathspa.ac.uk\u003c/a\u003e), who is available during 24th-31st July 2024 and 19th-23rd August 2024.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow for School-Centred Initial Teacher Training (SCITT) PGCE Programme","url":"https://bathspa.pinpointhq.com/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","path":"/en/postings/68fd9afd-7f4c-4d6f-b286-5b570e8321f6","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"213031","requisition_id":"282/23/24","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"196971","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 7 - £37,099 - £41,732 per annum\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eInterview Date - W/C 12th August\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-04T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eThis is an exciting opportunity to join us as Strategic Projects \u0026amp; Change Manager at Bath Spa University. You will be involved in a wide range of strategic activities and will play a key role in managing and facilitating change projects, new ways of working, and process improvements.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"full_time","employment_type_text":"Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs Strategic Projects \u0026amp; Change Manager you will manage project initiation phases, oversee large-scale programs, and ensure effective end-to-end project management. \u003cbr\u003e\u003cbr\u003eYou will work closely with senior leadership, project sponsors, and teams to meet project requirements, timelines, and outputs, while maintaining robust communication channels. \u003cbr\u003e\u003cbr\u003eYour role will involve coordinating project activities, supporting senior oversight groups, tracking project metrics, and developing best practice project management collateral. \u003cbr\u003e\u003cbr\u003eAdditionally, you will facilitate forums for cross-university collaboration, build strong networks across academic and professional services teams, and contribute to staff development and your own professional growth.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have excellent stakeholder management skills with a demonstrable ability to communicate effectively with a diverse audience will be key. \u003cbr\u003e\u003cbr\u003eYou will have a structured approach to producing accurate project documentation and reporting, be self-motivated, and experienced at working at a strategic level across a varied workload.\u003cbr\u003e\u003cbr\u003eIn addition, you will be flexible, calm under pressure and will have excellent organisational and prioritisation skills\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Strategic Projects \u0026 Change Manager","url":"https://bathspa.pinpointhq.com/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","path":"/en/postings/e7250083-f45a-44ec-a6eb-47c2295d169c","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"215223","requisition_id":"348/23/24","department":{"id":"36037","name":"Strategic Projects and Change Unit"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"197279","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade Ac2 - £37,099 - £41,732 per annum\u003cbr\u003e\u003cbr\u003eFull Time Fixed Term Contract initially for 12 months, although can be shortened or lengthened based on the maternity leave\u003cbr\u003e\u003cbr\u003eInterview Date - 14th August 2024\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£37,099 - £41,732 / year","compensation_minimum":37099.0,"compensation_maximum":41732.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking to recruit Teaching Fellows in Psychology to join our dedicated and committed team in Psychology.\u003cbr\u003e\u003cbr\u003e(Please note that the role is initially for 12 months, although can be shortened or lengthened based on the maternity leave)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will be the key support to undergraduate teaching across our programmes within Psychology. You will design and deliver teaching content across a range of modules at Levels 4 to 6 in Psychology Programmes, with a particular focus on Forensic Psychology, as well as contributing to curriculum planning and development, and engaging in research or scholarly activity in Psychology.\u003cbr\u003e\u003cbr\u003eYou will undertake teaching within Psychology in the form of lectures, practical sessions, seminars, discussions groups and tutorials as appropriate, whilst supporting undergraduate students individually and online.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eIn addition, you will help mark assessments associated with the teaching and will attend assessment and examination meetings as required.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking a flexible and positive individual who will be able to teach a broad range of Psychology at all undergraduate levels, with a particular focus on Forensic Psychology (though all areas of expertise are welcome) and have a BPS-Accredited undergraduate degree.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will have experience of teaching all aspects of general Psychology, as well as prior experience of different teaching methods and/or experience of university level teaching. As an excellent communicator, you will work successfully as part of a small team, whilst showing the ability to manage your own time with limited supervision.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role is available on a job-share basis that would enable you to complete postgraduate studies (e.g., a PhD) alongside the role.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor informal enquiries about the role, please contact Prof Peter Hills; \u003c/strong\u003e\u003ca href=\"mailto:p.hills@bathspa.ac.uk\"\u003e\u003cstrong\u003ep.hills@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Teaching Fellow in Psychology (Maternity Cover)","url":"https://bathspa.pinpointhq.com/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","path":"/en/postings/e060462c-ee93-44a7-ad9a-99117214a2e4","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"215498","requisition_id":"344/23/24","department":{"id":"25480","name":"School of Sciences"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198167","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a part time role, 28 hours per week.\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eGrade 6 - £24,457 - £27,261 per annum, pro rata £32,332-£36,024\u0026nbsp;\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eSome evening and weekend working during term time will be required.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£24,457 - £27,261 per annum, pro rata £32,332-£36,024 ","compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-08T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently seeking an dedicated Technical Demonstrator (moving image)\u003cstrong\u003e \u003c/strong\u003eto be responsible for the delivery of specialist technical skills demonstrations to either groups of students or one-to-one support to individuals here at Bath Spa University\u003cbr\u003e(This is a part time role, 28 hours per week)\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"part_time","employment_type_text":"Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role of a Technical Demonstrator combines technical knowledge and innovative thinking with the design and delivery of hardware and software demonstrations to students. Within the role you will be responsible for ensuring the maintenance of specialist equipment is carried out within own area of work and that health and safety standards are complied with. This role will be based around the delivery of training and demonstration of moving image capture, motion graphics generation, editing and gallery presentation. It will be located at the Locksbrook Rd campus mainly working with students enrolled on courses within the Schools of Art, Film and Media and the School of Design.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eAs Technical Demonstrator you will demonstrate complex technical techniques to students from various programs, support individual and group student work, and develop and run workshops on the use of our facilities. You will be responsible for preparing resources and equipment, supervising students' project work, and ensuring health and safety compliance within the workspace. Additionally, you will conduct risk assessments, maintain equipment, and stay updated with new technologies and contemporary practices in your field. You may also advise on future resource requirements and supervise a small team of technical staff.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be a qualified Workshop and Laboratory Technician with an NVQ4, NEBSS, or degree in a relevant practical subject, or significant professional experience in a specialist area. You will have experience in demonstration or training, supervisory skills, and expertise in video capture, motion graphics, animation, and gallery presentation of moving images.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou should demonstrate a proactive approach to maintenance, development, and safety, possess excellent interpersonal, written, and oral communication skills, and have strong ICT capabilities.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe role requires the ability to plan and organise work, manage resources, liaise with staff, departments, and external agencies, use initiative and problem-solving skills, make decisions, and work under pressure to tight deadlines. Flexibility, adaptability, and a positive approach to change are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Technical Demonstrator (Moving Image)","url":"https://bathspa.pinpointhq.com/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","path":"/en/postings/65903176-ecd1-4a12-87c1-cb8a564a7400","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"216378","requisition_id":"347/23/24","department":{"id":"30746","name":"Technical Services"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"198471","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the Games Development and Creative Computing (Games) courses at Bath Spa University.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of games design and development.\u0026nbsp;\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institution in games development or similar Creative Computing subjects. We expect that as a games and creative technology specialist, you will be actively engaged in related practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will ideally have additional industry and/or teaching experience using modern game engines such Unity3D and Unreal, and some knowledge of others. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience in a game production role is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer – Games Development","url":"https://bathspa.pinpointhq.com/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","path":"/en/postings/0c006e1a-907b-4252-bf41-72f72d7a8649","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216674","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198483","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - From 5th August 2024.\u003cbr\u003e\u003cbr\u003ePlease note:\u0026nbsp;\u003cbr\u003eINTERVIEWS WILL BE ONGOING AND THE JOB WILL CLOSE ONCE ALL POSITIONS ARE FILLED\u003cbr\u003e\u003cbr\u003ePlease email David Cobb directly d.cobb@bathspa.ac.uk for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are seeking knowledgeable and enthusiastic computing educators to support learning within the BSc (HONS) Computing course at Bath Spa University. \u003cbr\u003e\u003cbr\u003eThe individual(s) will be responsible for the planning, delivery and assessment of modules focused on subjects within the field of Computing.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe successful candidate(s) will play an important role in developing the knowledge and skills of undergraduate students.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThey will work as part of the computing team to provide mentorship, deliver robust assessment and overall maintain a high-level industry-informed experience.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have experience in delivering and leading teaching and learning in a Further and/or Higher Education institute in Computing subjects. We expect that as a Computing specialist, you will be actively engaged in computing practice and able to translate your professional interests into the teaching and learning practices on the course.\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eYou will have industry and/or teaching experience within one or more of the following areas: OO software development using C++, software engineering, and business analysis. You will have a degree in a relevant discipline, and you may have, or be working towards, a post graduate qualification. Experience developing creative and entertainment software is a bonus.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer - Computing","url":"https://bathspa.pinpointhq.com/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","path":"/en/postings/4f67e585-5248-4e1a-b3b1-579f95ec7227","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"216686","requisition_id":"","department":{"id":"19088","name":"School of Design"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"198822","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eWe encourage applications from disabled people and can provide reasonable adjustments, so please let us know if there is anything we can do to make applying for this role more accessible for you. \u0026nbsp;\u003cbr\u003e\u003cbr\u003eSalary: Grade 5 - £27,979 to £31,396 (per annum), £5,595.80 to £6,279.20 (pro-rata)\u003cbr\u003e\u003cbr\u003eThis is a 0.2 FTE part-time, one year fixed-term role.\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£27,979 - £31,396 / year","compensation_minimum":27979.0,"compensation_maximum":31396.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are currently\u003cstrong\u003e \u003c/strong\u003eseeking to appoint a Research Assistant to support the creation and development of a disability hub which aims to bring together and disseminate We Are The People research to the South West. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe Are The People (WATP) is a small research team of disabled academics and non-disabled allies engaged in disability research and disability activism. We've been awarded a five-year, £1million grant from the \u003ca href=\"https://wellcome.org/\"\u003e\u003cstrong\u003eWellcome Trust\u003c/strong\u003e\u003c/a\u003e to explore issues which affect disabled people in South West England.\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_part_time","employment_type_text":"Fixed Term - Part Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eThe role involves developing an understanding of ongoing research by Disabled People’s Organisations (DPOs), creating a disability training programme led by disabled individuals, and organizing events to showcase findings. You will ensure the accessible dissemination of research results, investigate collaborative opportunities with DPOs, and build relationships with community contacts for future funding.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eKey responsibilities include providing guidance to community partners, contributing to meetings, adhering to Health and Safety guidelines, and developing research methods within the programme framework.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will be passionate about disability equality and hold a good first degree in a relevant discipline such as Disability Studies, Psychology, Social Science, Arts, etc. You will also have demonstrable experience of working in a co-productive way with project partners, contributing to a community, charity or research environment.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eYou will also show a demonstrable understanding of the sensitivities of working with underrepresented groups, and to respond to potential barriers in a compassionate way. In addition, you will be an excellent problem solver, flexible, adaptable and a committed team player. \u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eFor an informal discussion regarding this post, please contact the team at: \u003ca href=\"mailto:WeAreThePeople@bathspa.ac.uk\"\u003eWeAreThePeople@bathspa.ac.uk\u003c/a\u003e \u0026nbsp;\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Research Assistant - We Are The People project","url":"https://bathspa.pinpointhq.com/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","path":"/en/postings/d127a868-2a02-482a-aae8-d9343c0d167e","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217032","requisition_id":"360_23_24  ","department":{"id":"25479","name":"School of Education"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199360","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis role is a one year fixed-term contact.\u003cbr\u003e\u003cbr\u003eSalary: Grade 8s, £42,978 to £44,263\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£42,978 - £44,263 / year","compensation_minimum":42978.0,"compensation_maximum":44263.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-11T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eBath Spa University is seeking a dynamic and innovative Head of Recruitment to lead and deliver cutting-edge resourcing solutions.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eThis role focuses on developing sustainable staff recruitment strategies, optimizing our employer value proposition (EVP), and enhancing our recruitment branding across all platforms. (This is a 1 year Fixed Term Contract)\u0026nbsp;\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eYou will oversee a smooth and efficient recruitment process, enhancing both the candidate and hiring manager experience and will lead the recruitment team, providing expert guidance and support. Collaborating with senior managers, you will understand strategic recruitment needs and determine the best resourcing strategies. Proactive sourcing of hard-to-fill or senior roles through headhunting, microsites, and video content will be essential.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eSetting and reviewing key performance indicators (KPIs) will be a critical part of the role, ensuring effective recruitment processes and annual reporting on trends. You will embed our EVP through recruitment marketing techniques aligned with the University's values and culture and will build BSU’s presence on social media to increase engagement. Implementing initiatives to improve workforce diversity and ensuring recruitment efforts align with the University’s Equality, Diversity, and Inclusion (ED\u0026amp;I) Strategy is vital. Inclusive recruitment practices must be maintained throughout the candidate journey, and you will influence line managers to prioritise talent diversity.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eEstablishing and managing a talent pool process for future vacancies will be part of your remit, as well as building external networks to stay updated on recruitment trends and advising the University accordingly.\u0026nbsp;\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eYou will have proven expertise in employee resourcing strategies and recruitment processes, strong leadership and team management skills, and experience in developing and implementing EVP.\u0026nbsp;\u003cbr\u003e\u003cbr\u003eProficiency in utilising social media for recruitment, a commitment to diversity and inclusion in the workplace, and excellent communication and relationship-building skills are essential.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Head of Recruitment","url":"https://bathspa.pinpointhq.com/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","path":"/en/postings/f3d2b05e-f64f-492c-914b-9f5e3dbe1aae","workplace_type":"hybrid","workplace_type_text":"Hybrid","job":{"id":"217566","requisition_id":"254-23-24","department":{"id":"19087","name":"HR"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199810","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eTemporary, fixed term Semester/Trimester one and two 2024 -2025. Part Time Hours to be agreed.\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eGeneral teaching commences week beginning 30th September 2024 but module development will before these date. Our 2024/5 term dates can be found at https://www.bathspa.ac.uk/about-us/term-dates/\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-19T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eWe are looking for talented Associate Lecturers in Law to join our collegial team, contributing to teaching and development of law modules on a part time basis at various times through the 2024/2025 academic year.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Associate Lecturer posts require lecturing, taking seminar groups, assessment and working as part of a team of tutors.\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAt Bath Spa University we work with one clear vision: to be a leading university in creativity, culture and enterprise. And we place collaboration at the heart of everything we do. With ever growing student numbers, we make sure our people are engaged and empowered by blending digital technologies, international perspectives, work-oriented connections and inspirational teaching. Together we’re on a journey to transform our students’ lives. And it starts with people like you.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eAbout Bath Business School\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eBath Business School is set within a beautiful countryside location, close to the world heritage city of Bath. Our staff and students are ethically aware, socially engaged and globally connected through our links to research, and professional and creative industry networks.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eOur Law Degree\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eOur new LLB Law degree has been designed to be unique and incorporates a range of business skills and optional modules whilst encompassing the foundations of legal knowledge found in SQE 1 and many elements of SQE 2.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eThe Bath Spa LLB is at the cutting edge of legal education. Our LLB offers a range of authentic assessments, the offer of multiple placement opportunities including a placement year, as well as the opportunity of undertaking the Law Clinic module for final year students.\u0026nbsp; Our Law Clinic is a result of an impressive joint venture between Bath Spa University, Stone King LLP and the Citizens Advice Bureau BANES.\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u0026nbsp;\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eWe believe in giving our students a high-quality educational experience, exceptional opportunities to become highly employable as well as unrivalled pastoral care.\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eFor further information contact Steven Goulton, Law Course Director, Bath Business School, \u003c/strong\u003e\u003ca href=\"mailto:s.goulton@bathspa.ac.uk\"\u003e\u003cstrong\u003es.goulton@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e.\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e","key_responsibilities_header":"About Us.","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eIdeally you will have expertise in one or more of the following areas (please see below for further information on Associate Lecturer role specifics):\u003c/div\u003e\u003cul\u003e\u003cli\u003e\u003c!--block--\u003eTort Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmployment Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eBusiness Law\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eDissertation supervision\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEquity and trusts\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eProperty Law\u0026nbsp;\u003c/li\u003e\u003cli\u003e\u003c!--block--\u003eEmerging technologies – AI, cyberlaw etc\u003c/li\u003e\u003c/ul\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer in Law","url":"https://bathspa.pinpointhq.com/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","path":"/en/postings/cbcf5a29-2baf-4a98-a523-8f2d00649abc","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218013","requisition_id":"","department":{"id":"19085","name":"Business School"},"division":null,"structure_custom_group_one":null},"location":{"id":"14958","city":"Bath ","name":"Bath - Newton Park","province":"Bath"}},{"id":"199873","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eDue to the nature of this post regretfully we cannot accept applications that do not have the Right to Work/Live in the UK therefore your application will be rejected.\u003c/strong\u003e\u003cbr\u003e\u003cbr\u003e\u003cstrong\u003eGrade Ac2 - £19.23 per hour (a multiplier of 2.5 may be applied depending on the work offered)\u003cbr\u003e\u003cbr\u003eInterview Date - 11th \u0026amp; 12th September 2024\u003cbr\u003e\u003cbr\u003ePlease email Clara Giaminardi \u003c/strong\u003e\u003ca href=\"mailto:c.giaminardi@bathspa.ac.uk\"\u003e\u003cstrong\u003ec.giaminardi@bathspa.ac.uk\u003c/strong\u003e\u003c/a\u003e\u003cstrong\u003e directly for any queries regarding this position.\u003c/strong\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":null,"compensation_minimum":null,"compensation_maximum":null,"compensation_currency":null,"compensation_frequency":null,"compensation_visible":true,"deadline_at":"2024-08-31T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eOur BA (Hons) Fashion Photography course is looking for associate lecturers with in-depth knowledge and/or industry experience in the areas of fashion photography, fashion styling and fashion communication to deliver teaching on our level 4 and level 5 modules.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"flexible","employment_type_text":"Flexible","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eAs an associate lecturer on BA (Hons) Fasion Photography, your primary responsibility will be delivering engaging and high quality teaching in the appropriate subject area. This includes developing and undertaking in-person lectures, practical workshops, seminars and tutorials to support our level 4 and level 5 students in the development of their work.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003eIn the role, you will also be marking and assessing module work, providing constructive feedback and attending assessment meetings where required to ensure fair and consistent grading. You will also be expected to work closely with module staff and support on some administrative tasks, ensuring the smooth running of the module. This includes engaging with existing virtual learning environments to ensure cohesive dissemination of module materials and student communication across the course.\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eThe role requires an in-depth subject knowledge and/or industry expertise in the areas of fashion photography, fashion styling and/or fashion communication. You will have excellent communication and interpersonal skills and will be able to translate key skills and concepts into appropriate language and tasks for level 4 and level 5 students. A solid understanding of contemporary trends and industry practices is essential to ensure high quality of teaching for students going into future industry.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003ePrior experience teaching undergraduate students in these areas is desirable. You will have excellent organisational and time management skills, and be able to work successfully as part of a small team. Alongside solid IT skills, expertise in industry specific digital tools such as the Adobe Creative Suite is beneficial.\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Associate Lecturer, BA (Hons) Fashion Photography","url":"https://bathspa.pinpointhq.com/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","path":"/en/postings/95ba564d-f995-4af6-b333-c3719a45264c","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218077","requisition_id":"","department":{"id":"36272","name":"School of Art, Film \u0026 Media"},"division":null,"structure_custom_group_one":null},"location":{"id":"14959","city":"Bath","name":"Bath - Locksbrook Campus","province":"Bath"}},{"id":"200623","benefits":"\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003eThis is a Fixed Term Contract until November 2024.\u003cbr\u003e\u003cbr\u003eSalary: Grade 2, £23,152\u003cbr\u003e\u003cbr\u003eRecent adjustment in the UK’s Sponsorship Threshold\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003e\u0026nbsp;\u003c/strong\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cstrong\u003ePlease note that as of April 2024, there has been a change in the UK’s sponsorship threshold. Regrettably as the salary for this role falls beneath this, you will not be eligible for sponsorship therefore your application will automatically be rejected.\u003c/strong\u003e\u003cbr\u003e\u0026nbsp;\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e\u003cdiv\u003e\u003c!--block--\u003e\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","benefits_header":"Additional Information","compensation":"£23,152 / year","compensation_minimum":23152.0,"compensation_maximum":23152.0,"compensation_currency":"GBP","compensation_frequency":"year","compensation_visible":true,"deadline_at":"2024-08-05T23:59:59+01:00","description":"\u003cdiv\u003e\u003c!--block--\u003eExciting opportunity for a reliable and dedicated individual to join our elite Facilities and Services team in helping maintain a clean and safe environment on our Sion Hill Campus. (This is a Fixed Term Contract until November 2024)\u003cbr\u003e\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","employment_type":"fixed_term_full_time","employment_type_text":"Fixed Term - Full Time","key_responsibilities":"\u003cdiv\u003e\u003c!--block--\u003eOur team prides ourselves on our positive ‘can do’ approach towards supporting our students, staff and visitors.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eAs a valued member of our vibrant team, you'll be the unsung hero behind the scenes, transforming every corner of our campus into a sparkling haven of knowledge and innovation at the same time as providing excellent customer service.\u0026nbsp;\u003cbr\u003e\u0026nbsp;\u003cbr\u003eEmbrace the excitement of a dynamic environment where no two days are alike.\u003cbr\u003e\u003cbr\u003e\u003c/div\u003e","key_responsibilities_header":"About the Role","reporting_to":null,"skills_knowledge_expertise":"\u003cdiv\u003e\u003c!--block--\u003eDue to the University’s locations, having your own transport is recommended, however, there is the option of public transport (this is limited during the summer months).\u003cbr\u003e\u0026nbsp;\u003cbr\u003eCleaning experience is beneficial but what we’re looking for most is reliability, attention to detail and a willingness to learn.\u003cbr\u003e\u0026nbsp;\u003cstrong\u003e\u003cbr\u003e\u003c/strong\u003e\u003cbr\u003e\u003c/div\u003e","skills_knowledge_expertise_header":"About You","title":"Full Time Cleaner (Fixed Term Contract)","url":"https://bathspa.pinpointhq.com/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","path":"/en/postings/eef5984d-8e0a-4604-b941-da597332d95b","workplace_type":"onsite","workplace_type_text":"Onsite","job":{"id":"218783","requisition_id":"","department":{"id":"25473","name":"Estates"},"division":null,"structure_custom_group_one":null},"location":{"id":"14960","city":"Bath","name":"Bath - Sion Hill Campus","province":"Bath"}}]}
-  recorded_at: Mon, 29 Jul 2024 09:07:02 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:49 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Bath%20%20%20Newton%20Park,?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -361,7 +361,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:07:02 GMT
+      - Tue, 30 Jul 2024 16:28:53 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -379,18 +379,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - ea238aca37d6967ea6ff2bd208d767aa
+      - 7c62a938e7c12206c2e54aa3178d97c1
       X-Msedge-Ref:
-      - 'Ref A: B18506D65A6B494DB9B111741F842CF9 Ref B: DB3EDGE2010 Ref C: 2024-07-29T09:07:02Z|Ref
-        SnR: 66a75bb6a4d9496da9a87917d1753adf'
+      - 'Ref SnR: 66a914c5fffd4f8e88f68d24ce020eda|Ref A: 3BDA673D4FE3487CB53F81617F1C3595
+        Ref B: DB3EDGE2907 Ref C: 2024-07-30T16:28:53Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-lgrkj, mapsplatform-forwardgeocoder-service-69c675d4f5-j2djg
+      - mapsplatform-frontend-5989d449fd-zk7ph, mapsplatform-forwardgeocoder-service-69c675d4f5-9fk55
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '66'
+      - '63'
       X-Azure-Ref:
-      - 20240729T090702Z-154b59dbc6dh82c7m9kabap6k800000005w000000000fbss
+      - 20240730T162853Z-154b59dbc6d5skwk9um5h05e1s00000008ug000000012dn2
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -398,6 +398,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzUxLjM3MTY5NDIyODIzMDEwNSwtMi40NDY1ODM0MzExODQ1Mzk2LDUxLjM3OTQxOTY2MzM3MTQ2LC0yLjQzMDA4MzExNDY4MzM4MDNdLCJuYW1lIjoiTmV3dG9uIFBhcmssIFVuaXRlZCBLaW5nZG9tIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOls1MS4zNzU1NTY5NSwtMi40MzgzMzMyN119LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJFbmdsYW5kIiwiYWRtaW5EaXN0cmljdDIiOiJCYXRoIEFuZCBOb3J0aCBFYXN0IFNvbWVyc2V0IiwiY291bnRyeVJlZ2lvbiI6IlVuaXRlZCBLaW5nZG9tIiwiZm9ybWF0dGVkQWRkcmVzcyI6Ik5ld3RvbiBQYXJrLCBVbml0ZWQgS2luZ2RvbSJ9LCJjb25maWRlbmNlIjoiTWVkaXVtIiwiZW50aXR5VHlwZSI6IkxhbmRtYXJrQnVpbGRpbmciLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzUxLjM3NTU1Njk1LC0yLjQzODMzMzI3XSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19XX1dLCJzdGF0dXNDb2RlIjoyMDAsInN0YXR1c0Rlc2NyaXB0aW9uIjoiT0siLCJ0cmFjZUlkIjoiZWEyMzhhY2EzN2Q2OTY3ZWE2ZmYyYmQyMDhkNzY3YWEifQ==
-  recorded_at: Mon, 29 Jul 2024 09:07:02 GMT
+        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzUxLjM3MTY5NDIyODIzMDEwNSwtMi40NDY1ODM0MzExODQ1Mzk2LDUxLjM3OTQxOTY2MzM3MTQ2LC0yLjQzMDA4MzExNDY4MzM4MDNdLCJuYW1lIjoiTmV3dG9uIFBhcmssIFVuaXRlZCBLaW5nZG9tIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOls1MS4zNzU1NTY5NSwtMi40MzgzMzMyN119LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJFbmdsYW5kIiwiYWRtaW5EaXN0cmljdDIiOiJCYXRoIEFuZCBOb3J0aCBFYXN0IFNvbWVyc2V0IiwiY291bnRyeVJlZ2lvbiI6IlVuaXRlZCBLaW5nZG9tIiwiZm9ybWF0dGVkQWRkcmVzcyI6Ik5ld3RvbiBQYXJrLCBVbml0ZWQgS2luZ2RvbSJ9LCJjb25maWRlbmNlIjoiTWVkaXVtIiwiZW50aXR5VHlwZSI6IkxhbmRtYXJrQnVpbGRpbmciLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzUxLjM3NTU1Njk1LC0yLjQzODMzMzI3XSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19XX1dLCJzdGF0dXNDb2RlIjoyMDAsInN0YXR1c0Rlc2NyaXB0aW9uIjoiT0siLCJ0cmFjZUlkIjoiN2M2MmE5MzhlN2MxMjIwNmMyZTU0YWEzMTc4ZDk3YzEifQ==
+  recorded_at: Tue, 30 Jul 2024 16:28:53 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_recruitee.yml b/spec/fixtures/cassettes/create_job_recruitee.yml
index 2b306ceb..066a38d6 100644
--- a/spec/fixtures/cassettes/create_job_recruitee.yml
+++ b/spec/fixtures/cassettes/create_job_recruitee.yml
@@ -23,7 +23,7 @@ http_interactions:
       Content-Type:
       - application/json; charset=utf-8
       Date:
-      - Mon, 29 Jul 2024 09:07:02 GMT
+      - Tue, 30 Jul 2024 16:28:53 GMT
       Server:
       - Cowboy
       Strict-Transport-Security:
@@ -31,7 +31,7 @@ http_interactions:
       Vary:
       - accept-encoding
       X-Request-Id:
-      - F-aj0GtZY5oZRhIB7AjC
+      - F-cKgWBpG_56P40A6wlC
       Via:
       - 1.1 google
       Alt-Svc:
@@ -41,8 +41,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"offers":[{"hybrid":false,"slug":"copywriter-talen-pool","id":1390320,"title":"Copywriter Talent Pool","remote":true,"options_cover_letter":"optional","position":45,"locations_question":"What is your preferred work location?","state_code":"NY","postal_code":null,"department":null,"max_hours_per_week":"40.0","max_hours":null,"created_at":"2023-07-25 16:04:54 UTC","location_question_visible":false,"country":"United States","state_name":"New York","education_code":"bachelor_degree","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","close_at":null,"translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_image":null,"sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"locations_question_type":"multiple_choice","company_name":"Radish Lab","salary":{"max":null,"min":null,"period":null,"currency":null},"options_photo":"optional","tags":[],"min_hours_per_week":"30.0","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"options_cv":"required","locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","postal_code":null,"street":null,"note":null}},"country_code":"US","state_code":"NY","postal_code":null,"street":null,"note":null}],"city":"BROOKLYN","status":"published","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","cover_image":null,"updated_at":"2024-07-10 09:55:41 UTC","category_code":"design","employment_type_code":"contract","published_at":"2023-07-25 17:53:46 UTC","sharing_image":null,"country_code":"US","sharing_title":"Copywriter Talent Pool","location":"Remote job","careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool","locations_question_required":true,"guid":"56ucy","mailbox_email":"job.56ucy@radishlab.recruitee.com","options_phone":"required","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","min_hours":null,"on_site":false},{"hybrid":false,"slug":"project-manager-talent-pool","id":1357326,"title":"Project Manager Talent Pool","remote":true,"options_cover_letter":"optional","position":43,"locations_question":"What is your preferred work location?","state_code":"NY","postal_code":"11201","department":"Strategy & Project Management","max_hours_per_week":"40.0","max_hours":null,"created_at":"2023-06-21 22:11:24 UTC","location_question_visible":false,"country":"United States","state_name":"New York","education_code":"professional","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","close_at":null,"translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_image":null,"sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"locations_question_type":"multiple_choice","company_name":"Radish Lab","salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"options_photo":"off","tags":[],"min_hours_per_week":"30.0","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"options_cv":"required","locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","postal_code":"11201","street":"20 Jay Street","note":null}},"country_code":"US","state_code":"NY","postal_code":"11201","street":"20 Jay Street","note":null}],"city":"Brooklyn","status":"published","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","cover_image":null,"updated_at":"2024-06-10 18:24:23 UTC","category_code":"design","employment_type_code":"fulltime","published_at":"2023-06-21 22:14:02 UTC","sharing_image":null,"country_code":"US","sharing_title":"Project Manager Talent Pool","location":"Remote job","careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool","locations_question_required":true,"guid":"u4kva","mailbox_email":"job.u4kva@radishlab.recruitee.com","options_phone":"optional","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","min_hours":null,"on_site":false},{"hybrid":false,"slug":"developer-talent-pool","id":1333509,"title":"Developer Talent Pool","remote":true,"options_cover_letter":"optional","position":42,"locations_question":"What is your preferred work location?","state_code":"NY","postal_code":null,"department":"Development","max_hours_per_week":"40.0","max_hours":null,"created_at":"2023-05-31 13:38:00 UTC","location_question_visible":false,"country":"United States","state_name":"New York","education_code":"bachelor_degree","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","close_at":null,"translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_image":null,"sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"locations_question_type":"multiple_choice","company_name":"Radish Lab","salary":{"max":null,"min":null,"period":null,"currency":null},"options_photo":"optional","tags":[],"min_hours_per_week":"30.0","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"options_cv":"required","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","state_code":"NY","postal_code":null,"street":null,"note":null}],"city":"New York","status":"published","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","cover_image":null,"updated_at":"2024-06-30 19:58:06 UTC","category_code":"technical","employment_type_code":"contract","published_at":"2023-07-24 19:56:03 UTC","sharing_image":null,"country_code":"US","sharing_title":"Developer Talent Pool","location":"Remote job","careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool","locations_question_required":true,"guid":"pwpku","mailbox_email":"job.pwpku@radishlab.recruitee.com","options_phone":"required","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","min_hours":null,"on_site":false},{"hybrid":false,"slug":"design-talent-pool","id":1333465,"title":"Design Talent Pool","remote":true,"options_cover_letter":"optional","position":41,"locations_question":"What is your preferred work location?","state_code":"NY","postal_code":null,"department":"Design","max_hours_per_week":"40.0","max_hours":null,"created_at":"2023-05-31 13:19:38 UTC","location_question_visible":false,"country":"United States","state_name":"New York","education_code":"bachelor_degree","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","close_at":null,"translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_image":null,"sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"locations_question_type":"multiple_choice","company_name":"Radish Lab","salary":{"max":null,"min":null,"period":null,"currency":null},"options_photo":"optional","tags":[],"min_hours_per_week":"30.0","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"options_cv":"required","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","state_code":"NY","postal_code":null,"street":null,"note":null}],"city":"New York","status":"published","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","cover_image":null,"updated_at":"2024-07-10 01:26:39 UTC","category_code":"design","employment_type_code":"contract","published_at":"2023-07-24 19:56:30 UTC","sharing_image":null,"country_code":"US","sharing_title":"Design Talent Pool","location":"Remote job","careers_url":"https://radishlab.recruitee.com/o/design-talent-pool","locations_question_required":true,"guid":"2ccy3","mailbox_email":"job.2ccy3@radishlab.recruitee.com","options_phone":"required","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","min_hours":null,"on_site":false}]}
-  recorded_at: Mon, 29 Jul 2024 09:07:03 GMT
+        {"offers":[{"slug":"copywriter-talen-pool","company_name":"Radish Lab","id":1390320,"sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","title":"Copywriter Talent Pool","remote":true,"options_photo":"optional","state_name":"New York","locations_question_required":true,"position":45,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":null,"careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_image":null,"sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"employment_type_code":"contract","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-07-25 17:53:46 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","options_phone":"required","location":"Remote job","category_code":"design","updated_at":"2024-07-10 09:55:41 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"tags":[],"locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"postal_code":null,"sharing_title":"Copywriter Talent Pool","status":"published","guid":"56ucy","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":null,"min":null,"period":null,"currency":null},"on_site":false,"sharing_image":null,"city":"BROOKLYN","cover_image":null,"requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","created_at":"2023-07-25 16:04:54 UTC","options_cover_letter":"optional","education_code":"bachelor_degree","locations_question_type":"multiple_choice","mailbox_email":"job.56ucy@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>"},{"slug":"project-manager-talent-pool","company_name":"Radish Lab","id":1357326,"sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","title":"Project Manager Talent Pool","remote":true,"options_photo":"off","state_name":"New York","locations_question_required":true,"position":43,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":"Strategy & Project Management","careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool","translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_image":null,"sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"employment_type_code":"fulltime","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-06-21 22:14:02 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","options_phone":"optional","location":"Remote job","category_code":"design","updated_at":"2024-06-10 18:24:23 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"tags":[],"locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","postal_code":"11201","street":"20 Jay Street","note":null}},"country_code":"US","postal_code":"11201","state_code":"NY","street":"20 Jay Street","note":null}],"postal_code":"11201","sharing_title":"Project Manager Talent Pool","status":"published","guid":"u4kva","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"on_site":false,"sharing_image":null,"city":"Brooklyn","cover_image":null,"requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","created_at":"2023-06-21 22:11:24 UTC","options_cover_letter":"optional","education_code":"professional","locations_question_type":"multiple_choice","mailbox_email":"job.u4kva@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>"},{"slug":"developer-talent-pool","company_name":"Radish Lab","id":1333509,"sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","title":"Developer Talent Pool","remote":true,"options_photo":"optional","state_name":"New York","locations_question_required":true,"position":42,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":"Development","careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_image":null,"sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"employment_type_code":"contract","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-07-24 19:56:03 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","options_phone":"required","location":"Remote job","category_code":"technical","updated_at":"2024-06-30 19:58:06 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"tags":[],"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"postal_code":null,"sharing_title":"Developer Talent Pool","status":"published","guid":"pwpku","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":null,"min":null,"period":null,"currency":null},"on_site":false,"sharing_image":null,"city":"New York","cover_image":null,"requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","created_at":"2023-05-31 13:38:00 UTC","options_cover_letter":"optional","education_code":"bachelor_degree","locations_question_type":"multiple_choice","mailbox_email":"job.pwpku@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>"},{"slug":"design-talent-pool","company_name":"Radish Lab","id":1333465,"sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","title":"Design Talent Pool","remote":true,"options_photo":"optional","state_name":"New York","locations_question_required":true,"position":41,"state_code":"NY","min_hours":null,"country_code":"US","country":"United States","department":"Design","careers_url":"https://radishlab.recruitee.com/o/design-talent-pool","translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_image":null,"sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"employment_type_code":"contract","experience_code":"mid_level","max_hours_per_week":"40.0","published_at":"2023-07-24 19:56:30 UTC","location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","options_phone":"required","location":"Remote job","category_code":"design","updated_at":"2024-07-10 01:26:39 UTC","close_at":null,"hybrid":false,"open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"tags":[],"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"postal_code":null,"sharing_title":"Design Talent Pool","status":"published","guid":"2ccy3","max_hours":null,"min_hours_per_week":"30.0","salary":{"max":null,"min":null,"period":null,"currency":null},"on_site":false,"sharing_image":null,"city":"New York","cover_image":null,"requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","created_at":"2023-05-31 13:19:38 UTC","options_cover_letter":"optional","education_code":"bachelor_degree","locations_question_type":"multiple_choice","mailbox_email":"job.2ccy3@radishlab.recruitee.com","options_cv":"required","locations_question":"What is your preferred work location?","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>"}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:53 GMT
 - request:
     method: get
     uri: https://radishlab.recruitee.com/
@@ -68,7 +68,7 @@ http_interactions:
       Content-Type:
       - text/html; charset=utf-8
       Date:
-      - Mon, 29 Jul 2024 09:07:02 GMT
+      - Tue, 30 Jul 2024 16:28:53 GMT
       Referrer-Policy:
       - strict-origin-when-cross-origin
       Server:
@@ -86,7 +86,7 @@ http_interactions:
       X-Permitted-Cross-Domain-Policies:
       - none
       X-Request-Id:
-      - F-aj0HHtXYkZvlkBzzKj
+      - F-cKgWgYT3KKTb0A6woi
       Via:
       - 1.1 google
       Alt-Svc:
@@ -97,7 +97,7 @@ http_interactions:
       encoding: ASCII-8BIT
       string: !binary |-
         <!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>




      <meta content="Careers homepage" name="description"/>

      <meta content="Careers homepage" property="og:description"/>
      <meta content="https://radishlab.recruitee.com/" property="og:url"/>
      <meta content="Radish Lab" property="og:site_name"/>

      <meta content="website" property="og:type"/>

      <meta content="https://careers.recruiteecdn.com/image/upload/q_auto,w_1920,c_limit/production/images/AQJm/eTpqtQ6sZ9sc.jpeg" property="og:image"/>
      <meta content="800" property="og:image:width"/>
      <meta content="418" property="og:image:height"/>


<style data-styled="true" data-styled-version="5.1.1">.eFVUhY{font-size:32px;line-height:1.2em;color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:600;font-style:normal;text-transform:none;text-wrap:balance;margin-top:0px;margin-bottom:0px;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;word-break:normal;overflow-wrap:break-word;margin-top:28px;margin-bottom:28px;}/*!sc*/
@media only screen and (min-width:768px){.eFVUhY{font-size:48px;}}/*!sc*/
data-styled.g4[id="sc-1npqnwg-3"]{content:"eFVUhY,"}/*!sc*/
.fXpJdS{font-size:24px;line-height:1.2em;color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:600;font-style:normal;text-transform:none;text-wrap:balance;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;word-break:normal;overflow-wrap:break-word;margin-top:0px;margin-bottom:0px;margin-top:28px;margin-bottom:28px;}/*!sc*/
@media only screen and (min-width:768px){.fXpJdS{font-size:32px;}}/*!sc*/
data-styled.g6[id="sc-1npqnwg-5"]{content:"fXpJdS,"}/*!sc*/
.iPueVD{font-size:16px;line-height:1.6em;color:#000000;font-weight:400;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;margin-top:0px;margin-bottom:0px;margin-top:20px;margin-bottom:20px;}/*!sc*/
@media only screen and (min-width:768px){.iPueVD{font-size:20px;}}/*!sc*/
data-styled.g11[id="sc-1npqnwg-10"]{content:"iPueVD,"}/*!sc*/
.eDCgIN{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;}/*!sc*/
.eDCgIN::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.eDCgIN{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.eDCgIN{line-height:1.6em;}}/*!sc*/
.jmbcoz{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;font-size:16px;line-height:1.5em;}/*!sc*/
.jmbcoz::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{line-height:1.6em;}}/*!sc*/
@media only screen and (min-width:768px){.jmbcoz{font-size:16px;}}/*!sc*/
.xZUGZ{background:none;border:none;display:inline-block;font:inherit;margin:0;padding:0;outline:none;outline-offset:0;cursor:pointer;-webkit-appearance:none;-moz-appearance:none;appearance:none;font-size:16px;line-height:1.5em;position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;font-weight:600;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;text-align:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;border-radius:4px;-webkit-text-decoration:none;text-decoration:none;color:inherit;-webkit-transition:background-color 0.14s,color 0.14s;transition:background-color 0.14s,color 0.14s;padding:8px 12px;border:1px solid #000000;background-color:#000000;color:#ffffff;}/*!sc*/
.xZUGZ::-moz-focus-inner{border:none;padding:0;}/*!sc*/
@media only screen and (min-width:768px){.xZUGZ{font-size:20px;}}/*!sc*/
@media only screen and (min-width:768px){.xZUGZ{line-height:1.6em;}}/*!sc*/
.xZUGZ:hover{border:1px solid #000;background-color:#000;color:#ffffff;}/*!sc*/
data-styled.g13[id="sc-s03za1-0"]{content:"eDCgIN,jmbcoz,xZUGZ,"}/*!sc*/
.bIScAX{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-align-self:center;-ms-flex-item-align:center;align-self:center;color:currentColor;pointer-events:none;}/*!sc*/
data-styled.g21[id="sc-1rd450u-0"]{content:"bIScAX,"}/*!sc*/
.cPMqMQ{font-size:inherit;color:#000000;}/*!sc*/
data-styled.g43[id="sc-5egf6r-0"]{content:"cPMqMQ,"}/*!sc*/
.cKZGOF{line-height:1.5em;}/*!sc*/
.cKZGOF .sc-1tu8yb8-0{display:none;}/*!sc*/
.cKZGOF > :first-child{margin-top:0 !important;}/*!sc*/
.cKZGOF > :last-child{margin-bottom:0 !important;}/*!sc*/
data-styled.g45[id="sc-1tu8yb8-1"]{content:"cKZGOF,"}/*!sc*/
.gXycJU{width:16px;min-width:16px;}/*!sc*/
data-styled.g71[id="sc-1jf9qcy-0"]{content:"gXycJU,"}/*!sc*/
.beiMHd{display:none;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding:32px 0px;font-size:18px;line-height:normal;border-top:1px solid rgba(0,0,0,0.25);background-color:#fff;}/*!sc*/
data-styled.g89[id="sc-1ktojtq-0"]{content:"beiMHd,"}/*!sc*/
.eovEqQ{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
data-styled.g90[id="sc-1ktojtq-1"]{content:"eovEqQ,"}/*!sc*/
.gJxpwG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;min-height:66vh;}/*!sc*/
.gQRcOO{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;min-height:33vh;}/*!sc*/
.kmsnUh{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;position:relative;}/*!sc*/
data-styled.g91[id="sc-gfrfnr-0"]{content:"gJxpwG,gQRcOO,kmsnUh,"}/*!sc*/
.iVfIXi{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;background-repeat:no-repeat;background-position:center center;background-size:cover;z-index:1;}/*!sc*/
data-styled.g92[id="sc-gfrfnr-1"]{content:"iVfIXi,"}/*!sc*/
.deOrHQ{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;isolation:isolate;}/*!sc*/
data-styled.g93[id="sc-gfrfnr-2"]{content:"deOrHQ,"}/*!sc*/
@media only screen{.ixGbOy{display:block;}}/*!sc*/
@media only screen and (min-width:768px){.ixGbOy{display:block;}}/*!sc*/
data-styled.g94[id="sc-1oxti4r-0"]{content:"ixGbOy,"}/*!sc*/
.UZqcu{overflow:hidden;pointer-events:none;position:absolute;top:0;right:0;bottom:0;left:0;max-width:100%;max-height:100%;width:100%;height:100%;object-position:center center;object-fit:cover;z-index:0;}/*!sc*/
data-styled.g97[id="sc-itprxg-0"]{content:"UZqcu,"}/*!sc*/
.ebVyJP{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;position:relative;}/*!sc*/
data-styled.g101[id="sc-18h7are-0"]{content:"ebVyJP,"}/*!sc*/
.guycoN{width:100%;padding-top:48px;padding-bottom:48px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:992px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:1200px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
@media only screen and (min-width:1600px){.guycoN{padding-top:120px;padding-bottom:120px;}}/*!sc*/
.gZDsxt{width:100%;padding-top:20px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.gZDsxt{padding-top:40px;padding-bottom:40px;}}/*!sc*/
.kdUgoN{width:100%;padding-top:32px;padding-bottom:32px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:992px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:1200px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
@media only screen and (min-width:1600px){.kdUgoN{padding-top:80px;padding-bottom:80px;}}/*!sc*/
.hacApq{width:100%;padding-top:32px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.hacApq{padding-top:80px;padding-bottom:40px;}}/*!sc*/
.dLnXab{width:100%;padding-top:48px;padding-bottom:20px;}/*!sc*/
@media only screen{}/*!sc*/
@media only screen and (min-width:768px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:992px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1200px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
@media only screen and (min-width:1600px){.dLnXab{padding-top:120px;padding-bottom:40px;}}/*!sc*/
data-styled.g106[id="sc-1tu9fip-1"]{content:"guycoN,gZDsxt,kdUgoN,hacApq,dLnXab,"}/*!sc*/
.gJVWbp{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
.bSaXtg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;}/*!sc*/
data-styled.g107[id="sc-1tu9fip-2"]{content:"gJVWbp,bSaXtg,"}/*!sc*/
.jIYAZB{margin:0 auto;width:100%;max-width:calc(100% - 48px);}/*!sc*/
@media only screen and (min-width:768px){.jIYAZB{max-width:704px;}}/*!sc*/
@media only screen and (min-width:992px){.jIYAZB{max-width:920px;}}/*!sc*/
@media only screen and (min-width:1200px){.jIYAZB{max-width:1152px;}}/*!sc*/
data-styled.g109[id="sc-ji5wy4-0"]{content:"jIYAZB,"}/*!sc*/
.dbJNvX{margin:0 auto;width:100%;max-width:calc(100% - 48px);}/*!sc*/
@media only screen and (min-width:768px){.dbJNvX{max-width:704px;}}/*!sc*/
@media only screen and (min-width:992px){.dbJNvX{max-width:920px;}}/*!sc*/
@media only screen and (min-width:1200px){.dbJNvX{max-width:1152px;}}/*!sc*/
data-styled.g125[id="sc-1dj1hqi-0"]{content:"dbJNvX,"}/*!sc*/
.dDTKOA{--gap:0px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.bEnYHY{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.jEioAK{--gap:24px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.ebMZHP{--gap:16px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
.iozrWS{--gap:16px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;}/*!sc*/
.hohQBp{--gap:0px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;}/*!sc*/
data-styled.g126[id="sc-1dj1hqi-1"]{content:"dDTKOA,bEnYHY,jEioAK,ebMZHP,iozrWS,hohQBp,"}/*!sc*/
.dvhjIe{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.dvhjIe{width:100%;}}/*!sc*/
.hPupHS{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.hPupHS{width:calc( 50% - var(--gap) + ((var(--gap) / var(--columns)) * 6) );}}/*!sc*/
.fXdQP{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:100%;}/*!sc*/
@media only screen and (min-width:768px){.fXdQP{width:calc( 50% - var(--gap) + ((var(--gap) / var(--columns)) * 6) );}}/*!sc*/
.lbZeFW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;width:calc( 25% - var(--gap) + ((var(--gap) / var(--columns)) * 3) );}/*!sc*/
@media only screen and (min-width:768px){.lbZeFW{width:calc( 25% - var(--gap) + ((var(--gap) / var(--columns)) * 3) );}}/*!sc*/
data-styled.g127[id="sc-1dj1hqi-2"]{content:"dvhjIe,hPupHS,fXdQP,lbZeFW,"}/*!sc*/
.jLGbJs{-webkit-transition:background-color 0.14s ease-in-out,color 0.14s ease-in-out;transition:background-color 0.14s ease-in-out,color 0.14s ease-in-out;}/*!sc*/
data-styled.g128[id="sc-3k6t01-0"]{content:"jLGbJs,"}/*!sc*/
.kJLltb{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;max-width:calc(100% - 48px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-flex:1;-ms-flex:1;flex:1;}/*!sc*/
data-styled.g130[id="sc-1aabq8s-1"]{content:"kJLltb,"}/*!sc*/
.kcKagb{margin-left:14px;margin-right:-2px;}/*!sc*/
data-styled.g133[id="sc-1aabq8s-4"]{content:"kcKagb,"}/*!sc*/
.QEQag{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding-left:8px;padding-right:8px;-webkit-text-decoration:none;text-decoration:none;overflow:hidden;opacity:1;-webkit-transition:opacity 0.14s ease-in-out;transition:opacity 0.14s ease-in-out;height:80px;margin:-20px 0;color:#fff;color:inherit;}/*!sc*/
data-styled.g142[id="sc-pxbyo9-0"]{content:"QEQag,"}/*!sc*/
.klfKrz{display:block;width:auto;max-width:200px;max-height:55%;justify-self:start;margin-right:0;}/*!sc*/
@media only screen and (min-width:768px){.klfKrz{width:auto;}}/*!sc*/
data-styled.g143[id="sc-83wl6d-0"]{content:"klfKrz,"}/*!sc*/
.eNDDPg{white-space:nowrap;font-weight:600;font-size:16px;text-overflow:ellipsis;overflow:hidden;display:none;}/*!sc*/
@media only screen and (min-width:768px){.eNDDPg{overflow:initial;text-overflow:unset;font-size:22px;}}/*!sc*/
data-styled.g144[id="sc-83wl6d-1"]{content:"eNDDPg,"}/*!sc*/
.dPcHAE{display:inline-block;padding:8px 12px;font-size:16px;line-height:24px;text-align:center;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;margin:0 2px;color:#fff;font-weight:600;font-style:normal;text-transform:none;}/*!sc*/
.dPcHAE:hover,.dPcHAE:focus{background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g145[id="sc-ir8rf5-0"]{content:"dPcHAE,"}/*!sc*/
.hLPFpI{width:100%;border-radius:4px;overflow-x:hidden;overflow-y:auto;text-align:center;box-shadow:0 2px 8px rgba(0,0,0,0.12);padding:8px 4px;}/*!sc*/
body.is-keyboard-focused .hLPFpI [role='menuitem'][data-selected]{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
body.is-keyboard-focused .hLPFpI [role='menuitem']{-webkit-transition:undefined;transition:undefined;}/*!sc*/
@media only screen and (min-width:768px){.hLPFpI{width:auto;}}/*!sc*/
data-styled.g156[id="sc-1tu9xny-0"]{content:"hLPFpI,"}/*!sc*/
.kZTElj{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:58px;width:100%;text-align:center;padding:12px 16px;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;color:#000000;}/*!sc*/
.kZTElj[data-selected]{color:#000000;background-color:rgba(0,0,0,0.05);}/*!sc*/
data-styled.g157[id="sc-1tu9xny-1"]{content:"kZTElj,"}/*!sc*/
.iPvmIC{margin:1px 0;font-size:16px;line-height:22px;border-color:#fff;color:#fff;font-weight:600;font-style:normal;text-transform:none;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:40px;min-width:40px;margin:0px;}/*!sc*/
@media only screen and (min-width:768px){.iPvmIC{line-height:22px;}}/*!sc*/
.iPvmIC[data-selected],.iPvmIC:hover,.iPvmIC:focus{color:rgba(255,255,255,0.9);background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g158[id="sc-1tu9xny-2"]{content:"iPvmIC,"}/*!sc*/
.cAzrSG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;min-height:40px;min-width:40px;margin:0px;}/*!sc*/
data-styled.g159[id="sc-1tu9xny-3"]{content:"cAzrSG,"}/*!sc*/
.hlNgLl{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding:8px;margin:0 2px;text-align:center;-webkit-text-decoration:none;text-decoration:none;border-radius:4px;width:40px;height:40px;color:#fff;}/*!sc*/
.hlNgLl:hover{background-color:rgba(255,255,255,0.1);}/*!sc*/
data-styled.g167[id="sc-7glywv-0"]{content:"hlNgLl,"}/*!sc*/
.hdTF{list-style:none;padding-left:0;margin-top:0;margin-bottom:0;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;row-gap:8px;-webkit-box-pack:end;-webkit-justify-content:flex-end;-ms-flex-pack:end;justify-content:flex-end;}/*!sc*/
data-styled.g168[id="sc-1xewqye-0"]{content:"hdTF,"}/*!sc*/
@media only screen and (min-width:768px){.iudIDi{position:relative;}}/*!sc*/
data-styled.g174[id="sc-1tx5im8-0"]{content:"iudIDi,"}/*!sc*/
.hBOHsL{position:absolute;width:calc(100% - 48px);margin-left:24px;margin-right:24px;top:calc( 100% - 10px );left:0;z-index:1;}/*!sc*/
@media only screen and (min-width:768px){.hBOHsL{top:calc(100% + 10px);right:0;left:auto;width:-webkit-max-content;width:-moz-max-content;width:max-content;min-width:312px;margin-left:0;margin-right:0;}}/*!sc*/
.hBOHsL div[role='menu']{overscroll-behavior:contain;max-height:calc( 100vh - px - 12px );max-height:calc( 100dvh - px - 12px );}/*!sc*/
data-styled.g175[id="sc-1tx5im8-1"]{content:"hBOHsL,"}/*!sc*/
.cghDST{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;max-width:calc(100% - 48px);-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;-webkit-flex:1;-ms-flex:1;flex:1;}/*!sc*/
@media only screen and (min-width:768px){.cghDST{max-width:100%;-webkit-box-flex:unset;-webkit-flex-grow:unset;-ms-flex-positive:unset;flex-grow:unset;}}/*!sc*/
data-styled.g176[id="sc-1hkznj2-0"]{content:"cghDST,"}/*!sc*/
.guEbMs{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}/*!sc*/
data-styled.g177[id="sc-1hkznj2-1"]{content:"guEbMs,"}/*!sc*/
.dYPHZW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;width:100%;display:none;}/*!sc*/
@media only screen and (min-width:768px){.dYPHZW{width:100%;}}/*!sc*/
@media only screen and (min-width:992px){.dYPHZW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}}/*!sc*/
data-styled.g187[id="sc-it5itd-0"]{content:"dYPHZW,"}/*!sc*/
.ciZwhu{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
@media only screen and (min-width:768px){.ciZwhu{width:100%;}}/*!sc*/
@media only screen and (min-width:992px){.ciZwhu{display:none;}}/*!sc*/
data-styled.g188[id="sc-it5itd-1"]{content:"ciZwhu,"}/*!sc*/
.kllnfT{position:relative;}/*!sc*/
data-styled.g191[id="sc-z9o81a-0"]{content:"kllnfT,"}/*!sc*/
.fsBFXt{position:absolute;top:0;left:0;width:100%;z-index:2001;}/*!sc*/
data-styled.g192[id="sc-z9o81a-1"]{content:"fsBFXt,"}/*!sc*/
.hfKXfE{visibility:hidden;width:100%;pointer-events:none;}/*!sc*/
data-styled.g193[id="sc-lqj8ks-0"]{content:"hfKXfE,"}/*!sc*/
.bKUtEV{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;height:100%;width:100%;-webkit-align-items:flex-start;-webkit-box-align:flex-start;-ms-flex-align:flex-start;align-items:flex-start;}/*!sc*/
.hYJywo{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;height:100%;width:100%;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;}/*!sc*/
data-styled.g196[id="sc-pelm1o-0"]{content:"bKUtEV,hYJywo,"}/*!sc*/
.cOPlFo{width:100%;text-align:left;}/*!sc*/
.ipivQc{width:100%;text-align:center;}/*!sc*/
data-styled.g197[id="sc-pelm1o-1"]{content:"cOPlFo,ipivQc,"}/*!sc*/
.hmrXLz{width:100%;}/*!sc*/
data-styled.g198[id="sc-pelm1o-2"]{content:"hmrXLz,"}/*!sc*/
.iOQKaL{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
@media only screen and (min-width:768px){.iOQKaL{-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;}}/*!sc*/
.OebVS{--gap:48px;--columns:12;width:100%;gap:var(--gap);display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;-webkit-align-items:stretch;-webkit-box-align:stretch;-ms-flex-align:stretch;align-items:stretch;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start;}/*!sc*/
@media only screen and (min-width:768px){.OebVS{-webkit-flex-direction:row-reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse;}}/*!sc*/
data-styled.g199[id="sc-bq9z91-0"]{content:"iOQKaL,OebVS,"}/*!sc*/
.eDtYEt{z-index:1;}/*!sc*/
data-styled.g235[id="sc-1l3pw7p-0"]{content:"eDtYEt,"}/*!sc*/
.homvAg{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
data-styled.g356[id="sc-73r8cv-0"]{content:"homvAg,"}/*!sc*/
.ilRiFP{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;width:100%;background-color:#fff;min-height:inherit;}/*!sc*/
data-styled.g357[id="sc-73r8cv-1"]{content:"ilRiFP,"}/*!sc*/
.fDyLzp{position:relative;overflow:hidden;width:100%;}/*!sc*/
.fDyLzp::before{content:'';display:block;padding-bottom:100.00%;}/*!sc*/
data-styled.g369[id="sc-dkkku4-0"]{content:"fDyLzp,"}/*!sc*/
.dHdKMs{position:absolute;top:0;left:0;right:0;bottom:0;}/*!sc*/
data-styled.g370[id="sc-dkkku4-1"]{content:"dHdKMs,"}/*!sc*/
.cTyKMn{max-width:100%;width:100%;height:auto;}/*!sc*/
.ftWfoy{max-width:100%;width:100%;height:auto;object-fit:cover;height:100%;}/*!sc*/
data-styled.g373[id="sc-146moy0-0"]{content:"cTyKMn,ftWfoy,"}/*!sc*/
.lcroFG{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;width:100%;height:auto;position:relative;}/*!sc*/
data-styled.g390[id="sc-11gkm9w-0"]{content:"lcroFG,"}/*!sc*/
.YAzbZ{width:100%;height:auto;}/*!sc*/
data-styled.g391[id="sc-11gkm9w-1"]{content:"YAzbZ,"}/*!sc*/
.bpnyeu{position:relative;width:100%;height:100%;display:block;}/*!sc*/
data-styled.g434[id="sc-fw9s8b-0"]{content:"bpnyeu,"}/*!sc*/
.bJoAoi{font-size:16px;line-height:1.6em;color:#000000;font-weight:400;font-style:normal;text-transform:none;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;min-width:100%;color:#000000;border-collapse:collapse;}/*!sc*/
@media only screen and (min-width:768px){.bJoAoi{font-size:20px;}}/*!sc*/
.bJoAoi thead tr,.bJoAoi tbody tr:not(:last-of-type){border-bottom:1px solid rgba(0,0,0,0.25);}/*!sc*/
.bJoAoi th{color:rgba(0,0,0,0.8);font-weight:inherit;}/*!sc*/
.bJoAoi th,.bJoAoi td{height:64px;text-align:left;padding:8px;}/*!sc*/
.bJoAoi th:first-of-type,.bJoAoi td:first-of-type{padding-left:0;}/*!sc*/
.bJoAoi th:last-of-type,.bJoAoi td:last-of-type{padding-right:0;}/*!sc*/
.bJoAoi td{height:80px;}/*!sc*/
data-styled.g472[id="sc-18rtkup-0"]{content:"bJoAoi,"}/*!sc*/
.hhapWv{max-width:100%;overflow-x:auto;padding:0 4px;}/*!sc*/
data-styled.g473[id="sc-18rtkup-1"]{content:"hhapWv,"}/*!sc*/
.bqJcqI{color:#000000;font-weight:400;font-style:normal;text-transform:none;-webkit-text-decoration:none;text-decoration:none;word-break:break-word;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;}/*!sc*/
.bqJcqI:hover{color:#000;}/*!sc*/
data-styled.g474[id="sc-18rtkup-2"]{content:"bqJcqI,"}/*!sc*/
.ffHrMJ{margin:0 -4px;}/*!sc*/
data-styled.g475[id="sc-1qe5ahw-0"]{content:"ffHrMJ,"}/*!sc*/
.brHqfD{font-size:16px;line-height:24px;}/*!sc*/
data-styled.g476[id="sc-465zle-0"]{content:"brHqfD,"}/*!sc*/
.fTGeMR{margin-top:20px;padding-bottom:20px;border-bottom:1px solid rgba(0,0,0,0.25);}/*!sc*/
data-styled.g477[id="sc-465zle-1"]{content:"fTGeMR,"}/*!sc*/
.bCpqiX{font-weight:500;color:#000000;-webkit-text-decoration:none;text-decoration:none;word-break:break-word;-webkit-hyphens:auto;-moz-hyphens:auto;-ms-hyphens:auto;hyphens:auto;}/*!sc*/
.bCpqiX:hover{color:#000;}/*!sc*/
data-styled.g478[id="sc-465zle-2"]{content:"bCpqiX,"}/*!sc*/
.gkgGSG{position:relative;margin-top:8px;color:#000000;}/*!sc*/
data-styled.g479[id="sc-465zle-3"]{content:"gkgGSG,"}/*!sc*/
.jvvolj{width:20px;height:20px;display:inline-block;margin-right:8px;}/*!sc*/
.jvvolj > *{position:absolute;top:4px;left:0px;}/*!sc*/
data-styled.g480[id="sc-465zle-4"]{content:"jvvolj,"}/*!sc*/
.WxTrG{margin-top:12px;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;-webkit-align-items:end;-webkit-box-align:end;-ms-flex-align:end;align-items:end;gap:40px;}/*!sc*/
data-styled.g481[id="sc-465zle-5"]{content:"WxTrG,"}/*!sc*/
.exQcZ{display:none;}/*!sc*/
@media only screen and (min-width:768px){.exQcZ{display:block;}}/*!sc*/
data-styled.g482[id="sc-1dywz0m-0"]{content:"exQcZ,"}/*!sc*/
.gcbsVn{display:block;}/*!sc*/
@media only screen and (min-width:768px){.gcbsVn{display:none;}}/*!sc*/
data-styled.g483[id="sc-1dywz0m-1"]{content:"gcbsVn,"}/*!sc*/
.dWcJRW{display:block;}/*!sc*/
@media only screen and (min-width:768px){.dWcJRW{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}}/*!sc*/
data-styled.g490[id="sc-1mxcttb-0"]{content:"dWcJRW,"}/*!sc*/
.dPfocN{width:100%;}/*!sc*/
data-styled.g493[id="sc-4j8eof-0"]{content:"dPfocN,"}/*!sc*/
.jFfmvQ{-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;}/*!sc*/
data-styled.g494[id="sc-4j8eof-1"]{content:"jFfmvQ,"}/*!sc*/
.iOxTuT{opacity:1;}/*!sc*/
data-styled.g495[id="sc-4j8eof-2"]{content:"iOxTuT,"}/*!sc*/
.iZuBTr{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;text-align:left;}/*!sc*/
data-styled.g504[id="sc-1we8l0o-0"]{content:"iZuBTr,"}/*!sc*/
.kNKRnF{width:100%;-webkit-transition:width 0.1s linear,padding 0.1s linear;transition:width 0.1s linear,padding 0.1s linear;}/*!sc*/
@media only screen and (min-width:768px){.kNKRnF{width:100%;}}/*!sc*/
data-styled.g505[id="sc-1we8l0o-1"]{content:"kNKRnF,"}/*!sc*/
.gBDROR{position:absolute;top:0px;left:0px;border:0;-webkit-clip:rect(0 0 0 0);clip:rect(0 0 0 0);height:1px;width:1px;margin:-1px;padding:0;overflow:hidden;}/*!sc*/
.gBDROR:focus-within{background-color:#fff;z-index:1000;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:auto;height:auto;margin:0px;padding:6px;-webkit-clip:auto;clip:auto;}/*!sc*/
data-styled.g509[id="sc-q8cmux-0"]{content:"gBDROR,"}/*!sc*/
.kJsRIK{color:#000000;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,sans-serif;-webkit-text-decoration:none;text-decoration:none;}/*!sc*/
.kJsRIK:focus{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
data-styled.g510[id="sc-q8cmux-1"]{content:"kJsRIK,"}/*!sc*/
.jbcdEK{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;}/*!sc*/
data-styled.g511[id="sc-ax9y9i-0"]{content:"jbcdEK,"}/*!sc*/
html{line-height:1.15;-webkit-text-size-adjust:100%;}/*!sc*/
body{margin:0;}/*!sc*/
main{display:block;}/*!sc*/
h1{font-size:2em;margin:0.67em 0;}/*!sc*/
hr{box-sizing:content-box;height:0;overflow:visible;}/*!sc*/
pre{font-family:monospace,monospace;font-size:1em;}/*!sc*/
a{background-color:transparent;}/*!sc*/
abbr[title]{border-bottom:none;-webkit-text-decoration:underline;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;}/*!sc*/
b,strong{font-weight:bolder;}/*!sc*/
code,kbd,samp{font-family:monospace,monospace;font-size:1em;}/*!sc*/
small{font-size:80%;}/*!sc*/
sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline;}/*!sc*/
sub{bottom:-0.25em;}/*!sc*/
sup{top:-0.5em;}/*!sc*/
img{border-style:none;}/*!sc*/
button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0;}/*!sc*/
button,input{overflow:visible;}/*!sc*/
button,select{text-transform:none;}/*!sc*/
button,[type='button'],[type='reset'],[type='submit']{-webkit-appearance:none;}/*!sc*/
button::-moz-focus-inner,[type='button']::-moz-focus-inner,[type='reset']::-moz-focus-inner,[type='submit']::-moz-focus-inner{border-style:none;padding:0;}/*!sc*/
fieldset{padding:0.35em 0.75em 0.625em;}/*!sc*/
legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal;}/*!sc*/
progress{vertical-align:baseline;}/*!sc*/
textarea{overflow:auto;}/*!sc*/
[type='checkbox'],[type='radio']{box-sizing:border-box;padding:0;}/*!sc*/
[type='number']::-webkit-inner-spin-button,[type='number']::-webkit-outer-spin-button{height:auto;}/*!sc*/
[type='search']{-webkit-appearance:textfield;outline-offset:0;}/*!sc*/
[type='search']::-webkit-search-decoration{-webkit-appearance:none;}/*!sc*/
::-webkit-file-upload-button{-webkit-appearance:button;font:inherit;}/*!sc*/
[type='number']::-webkit-inner-spin-button,[type='number']::-webkit-outer-spin-button{-webkit-appearance:none;margin:0;}/*!sc*/
[type='number']{-moz-appearance:textfield;}/*!sc*/
details{display:block;}/*!sc*/
summary{display:list-item;}/*!sc*/
template{display:none;}/*!sc*/
[hidden]{display:none;}/*!sc*/
*{box-sizing:border-box;}/*!sc*/
html{-webkit-overflow-scrolling:touch;-webkit-scroll-behavior:auto;-moz-scroll-behavior:auto;-ms-scroll-behavior:auto;scroll-behavior:auto;}/*!sc*/
body{min-height:100vh;padding:0;margin:0;background-color:#f1f4f7;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',"Roboto",'Helvetica Neue',"Helvetica","Arial",sans-serif;font-size:16px;line-height:1.5;color:#000;font-variant-ligatures:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;-webkit-overflow-scrolling:touch;overscroll-behavior-y:none;}/*!sc*/
h1,h2,h3,h4,h5,h6,blockquote{line-height:1.15;margin:0;}/*!sc*/
*:focus{outline:none;}/*!sc*/
body.is-keyboard-focused *:focus{outline:2px solid #005fcc;outline-offset:2px;box-shadow:white 0px 0px 0px 2px inset;}/*!sc*/
[inert]{pointer-events:none;cursor:default;}/*!sc*/
[inert],[inert] *{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}/*!sc*/
:root{--reach-slider:1;--reach-dialog:1;--reach-tabs:1;--reach-combobox:1;--reach-menu-button:1;--reach-accordion:1;--reach-skip-nav:1;}/*!sc*/
.custom-css-apply-with-custom-integrations{width:100%;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;gap:16px;margin-top:16px;margin-bottom:16px;}/*!sc*/
.custom-css-apply-with-custom-integrations:empty{margin-bottom:0;}/*!sc*/
data-styled.g512[id="sc-global-jTVnrn1"]{content:"sc-global-jTVnrn1,"}/*!sc*/
</style>





<meta data-react-helmet="true" content="Careers homepage" name="title"/><meta data-react-helmet="true" content="Careers homepage" property="og:title"/>

<script data-react-helmet="true" data-testid="custom-integrations-window-api">
        window.recruitee = window.recruitee || {};
        window.recruitee.customIntegrationsApi = window.recruitee.customIntegrationsApi || {"companyId":53295,"offerId":null,"offer":null};
      </script>
<title data-react-helmet="true">Careers homepage</title>




    <style>
      body > div[data-component="PublicApp"] {
        display: -webkit-box;
        display: -webkit-flex;
        display: -ms-flexbox;
        display: flex;
        -webkit-flex-direction: column;
        -ms-flex-direction: column;
        flex-direction: column;
        min-height: inherit;
      }
    </style>
  </head>
  <body>
<div data-rendered data-component="PublicApp" data-props="{&quot;appConfig&quot;:{&quot;agreements&quot;:[],&quot;analyticsBaseUrl&quot;:&quot;https://careers-analytics.recruitee.com&quot;,&quot;appEnv&quot;:&quot;production&quot;,&quot;atsHost&quot;:&quot;recruitee.com&quot;,&quot;captcha&quot;:{&quot;apiHost&quot;:&quot;https://captcha-base.recruiteecdn.com&quot;,&quot;assetHost&quot;:&quot;https://captcha-assets.recruiteecdn.com&quot;,&quot;imageHost&quot;:&quot;https://captcha-imgs.recruiteecdn.com&quot;,&quot;reportHost&quot;:&quot;https://captcha-report.recruiteecdn.com&quot;,&quot;siteKey&quot;:&quot;d111bc04-7616-4e05-a1da-9840968d2b88&quot;},&quot;cookiesConsent&quot;:{&quot;isEnabled&quot;:false,&quot;translations&quot;:{&quot;en&quot;:{&quot;agreeToAllCookies&quot;:&quot;Agree to all&quot;,&quot;agreeToNecessaryCookies&quot;:&quot;Agree to necessary&quot;,&quot;agreeToSelectedCookies&quot;:&quot;Agree to selected&quot;,&quot;bigCookiePlaceholderCta&quot;:&quot;Cookie preferences&quot;,&quot;bigCookiePlaceholderTitle&quot;:&quot;But first, cookies ;)&quot;,&quot;bigCookiePlaceholderVimeoDescription&quot;:&quot;We can&#39;t display this video. Please allow Vimeo cookies to watch it.&quot;,&quot;bigCookiePlaceholderYoutubeDescription&quot;:&quot;We can&#39;t display this video. Please allow YouTube cookies to watch it.&quot;,&quot;consentButtonLabel&quot;:null,&quot;description&quot;:null,&quot;dialogDescription&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;We use cookies to ensure that we give you the best experience on our website.&quot;}],&quot;type&quot;:&quot;p&quot;}],&quot;dialogTitle&quot;:&quot;Cookies agreement&quot;,&quot;hideSettings&quot;:&quot;Hide options&quot;,&quot;necessary&quot;:&quot;Necessary&quot;,&quot;necessaryCookies&quot;:&quot;Necessary cookies&quot;,&quot;necessaryCookiesDescription&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Some cookies are required to provide core functionality. The website might not function properly without these cookies, they are enabled by default and cannot be disabled.&quot;}],&quot;type&quot;:&quot;p&quot;}],&quot;optionalCookies&quot;:&quot;Optional cookies&quot;,&quot;showLess&quot;:&quot;Show less&quot;,&quot;showMore&quot;:&quot;Show more&quot;,&quot;showSettings&quot;:&quot;More options&quot;,&quot;smallCookiePlaceholderCta&quot;:&quot;Update cookies&quot;,&quot;smallCookiePlaceholderDescription&quot;:&quot;unavailable&quot;,&quot;title&quot;:null}},&quot;updatedAt&quot;:&quot;2000-01-01T00:00:00&quot;},&quot;customFontFamilies&quot;:[],&quot;departments&quot;:[{&quot;id&quot;:108703,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Development&quot;}}},{&quot;id&quot;:108710,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Administration&quot;}}},{&quot;id&quot;:129247,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;adm&quot;}}},{&quot;id&quot;:108708,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Strategy &amp; Project Management&quot;}}},{&quot;id&quot;:108702,&quot;translations&quot;:{&quot;en&quot;:{&quot;name&quot;:&quot;Design&quot;}}}],&quot;featureFlags&quot;:{&quot;applyWithXing&quot;:true,&quot;careersAnalytics&quot;:true,&quot;customCodeSection&quot;:true,&quot;customIntegrations&quot;:true,&quot;hcaptcha&quot;:true,&quot;internalPages&quot;:true,&quot;jobCoverImage&quot;:true,&quot;manageLocations&quot;:true,&quot;screeningQuestionDate&quot;:true,&quot;siteMigrator&quot;:true,&quot;texting&quot;:true},&quot;initialLocation&quot;:&quot;/&quot;,&quot;internalIntegrations&quot;:[{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;xing&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with XING feature. The Apply with XING feature allows you to apply for jobs by using your XING profile. When you click Apply with XING on our site, we&#39;ll pre-populate some of the job application fields with your profile data and automatically attach your complete XING profile to the application form. This means that we will be able to easily access your complete XING profile as we look through your application. For details about the cookies used and the data received see XING&#39;s Cookie Policy. Apply with XING is subject to XING&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://privacy.xing.com/en/privacy-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:1014388,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;XING&quot;,&quot;type&quot;:&quot;xing&quot;,&quot;updatedAt&quot;:&quot;2024-01-12T12:56:26&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[{&quot;category&quot;:&quot;necessary&quot;,&quot;key&quot;:null,&quot;name&quot;:&quot;_cs_consent&quot;,&quot;provenance&quot;:&quot;first-party&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Stores the user&#39;s cookie consent state for the current domain.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}}],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;careers&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null}}},&quot;id&quot;:458454,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;CareersHub&quot;,&quot;type&quot;:&quot;careers&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;google-analytics&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;We use Google Analytics to track visitor behaviour and measure site performance. For details about the cookies used and the data received see Google&#39;s Cookie Policy. Cookies placed by Google Analytics are subject to Google’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://policies.google.com/technologies/cookies&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458455,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;Google Analytics&quot;,&quot;settings&quot;:{&quot;token&quot;:&quot;&quot;},&quot;type&quot;:&quot;google-analytics&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;youtube&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables embedded YouTube player feature. For details about the cookies used and the data received see Google&#39;s Cookie Policy. Cookies placed by embedded YouTube players are subject to Google’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://policies.google.com/technologies/cookies&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458456,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Youtube&quot;,&quot;type&quot;:&quot;youtube&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;vimeo&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables embedded Vimeo player feature. For details about the cookies used and the data received see Vimeo&#39;s Cookie Policy. Cookies placed by embedded Vimeo players are subject to Vimeo’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://vimeo.com/cookie_policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458457,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Vimeo&quot;,&quot;type&quot;:&quot;vimeo&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;linkedin&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with LinkedIn feature. The Apply with LinkedIn feature allows you to apply for jobs by using your LinkedIn profile. When you click Apply with LinkedIn on our site, we&#39;ll pre-populate some of the job application fields with your profile data and automatically attach your complete LinkedIn profile to the application form. This means that we will be able to easily access your complete LinkedIn profile as we look through your application. For details about the cookies used and the data received see LinkedIn&#39;s Cookie Policy. Apply with LinkedIn is subject to LinkedIn&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.linkedin.com/legal/cookie-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458458,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;LinkedIn&quot;,&quot;settings&quot;:{&quot;isApplyWithLinkedInOn&quot;:true},&quot;type&quot;:&quot;linkedin&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;indeed&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables Apply with Indeed feature. The Apply with Indeed feature allows you to quickly apply using an Indeed Resume. For details about the cookies used and the data received see Indeed&#39;s Privacy Policy. Apply with Indeed is subject to Indeed&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Privacy Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.indeed.com/legal&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:458459,&quot;isIntegrated&quot;:true,&quot;name&quot;:&quot;Indeed&quot;,&quot;settings&quot;:{&quot;isApplyWithIndeedOn&quot;:true},&quot;type&quot;:&quot;indeed&quot;,&quot;updatedAt&quot;:&quot;2021-09-27T14:55:38&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:false,&quot;key&quot;:&quot;kununu&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Enables kununu Live Score feature. The kununu Live Score feature allows you to view our current kununu employer score. For details about the cookies used and the data received see kununu&#39;s privacy policy. kununu Live Score is subject to kununu’s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Privacy Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://privacy.xing.com/en/privacy-policy&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:680112,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;kununu&quot;,&quot;type&quot;:&quot;kununu&quot;,&quot;updatedAt&quot;:&quot;2021-11-09T16:58:54&quot;},{&quot;cookieSettings&quot;:{&quot;cookies&quot;:[],&quot;isConsentRequired&quot;:true,&quot;key&quot;:&quot;facebook-pixel&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Allows us to measure the effectiveness of our advertising by understanding the actions that visitors take on our website. For details about the cookies used and the data received see Facebook&#39;s Cookie Policy. Cookies placed by Facebook Pixel are subject to Facebook&#39;s &quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Cookie Policy&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.facebook.com/policies/cookies/&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;id&quot;:811110,&quot;isIntegrated&quot;:false,&quot;name&quot;:&quot;Facebook Pixel&quot;,&quot;settings&quot;:{&quot;pixelId&quot;:&quot;&quot;},&quot;type&quot;:&quot;facebook-pixel&quot;,&quot;updatedAt&quot;:&quot;2022-06-14T19:53:57&quot;}],&quot;isApplicationFormApplicationDisabled&quot;:null,&quot;isOfferAtsPreview&quot;:null,&quot;isOfferMockFallbackAllowed&quot;:null,&quot;languages&quot;:{&quot;en&quot;:&quot;English&quot;},&quot;offers&quot;:[{&quot;city&quot;:&quot;New York&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108703,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1333509,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;pwpku&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:813298,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91709,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;New York&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;New York&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:42,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;developer-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Developer Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Developer Talent Pool&quot;}}},{&quot;city&quot;:&quot;Brooklyn&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108708,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1357326,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;optional&quot;,&quot;photo&quot;:&quot;off&quot;},&quot;guid&quot;:&quot;u4kva&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:782556,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91708,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;Brooklyn&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;Brooklyn, 11201 (2)&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:&quot;11201&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:&quot;20 Jay Street&quot;}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:false,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:43,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:&quot;USD&quot;,&quot;max&quot;:6.8e4,&quot;min&quot;:5.2e4,&quot;period&quot;:&quot;year&quot;},&quot;slug&quot;:&quot;project-manager-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:&quot;20 Jay Street&quot;,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a &quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Project Manager Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Project Manager Talent Pool&quot;}}},{&quot;city&quot;:&quot;New York&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:108702,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1333465,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;2ccy3&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:813299,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91709,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;New York&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;New York&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:41,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;design-talent-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;We are always looking for passionate, talented designers to join our team but don&#39;t always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Design Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Design Talent Pool&quot;}}},{&quot;city&quot;:&quot;BROOKLYN&quot;,&quot;countryCode&quot;:&quot;US&quot;,&quot;coverImage&quot;:null,&quot;departmentId&quot;:null,&quot;eeoEnabled&quot;:false,&quot;externalId&quot;:1390320,&quot;fields&quot;:{&quot;coverLetter&quot;:&quot;optional&quot;,&quot;cv&quot;:&quot;required&quot;,&quot;phone&quot;:&quot;required&quot;,&quot;photo&quot;:&quot;optional&quot;},&quot;guid&quot;:&quot;56ucy&quot;,&quot;hybrid&quot;:false,&quot;id&quot;:814442,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locations&quot;:[{&quot;countryCode&quot;:&quot;US&quot;,&quot;id&quot;:91700,&quot;stateCode&quot;:&quot;NY&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;city&quot;:&quot;BROOKLYN&quot;,&quot;country&quot;:&quot;United States&quot;,&quot;name&quot;:&quot;BROOKLYN&quot;,&quot;note&quot;:null,&quot;postalCode&quot;:null,&quot;state&quot;:&quot;New York&quot;,&quot;street&quot;:null}}}],&quot;locationsQuestionRequired&quot;:true,&quot;locationsQuestionType&quot;:&quot;multiple_choice&quot;,&quot;onSite&quot;:false,&quot;options&quot;:{&quot;isApplyWithIndeedOn&quot;:true,&quot;isApplyWithLinkedInOn&quot;:false,&quot;isApplyWithXingOn&quot;:false,&quot;isLocationOnOfferPageOn&quot;:true,&quot;isLocationsQuestionOn&quot;:false,&quot;isSocialMediaShareOn&quot;:true},&quot;position&quot;:45,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;remote&quot;:true,&quot;salary&quot;:{&quot;currency&quot;:null,&quot;max&quot;:null,&quot;min&quot;:null,&quot;period&quot;:null},&quot;slug&quot;:&quot;copywriter-talen-pool&quot;,&quot;status&quot;:&quot;published&quot;,&quot;street&quot;:null,&quot;tags&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;country&quot;:&quot;United States&quot;,&quot;descriptionHtml&quot;:null,&quot;highlightHtml&quot;:null,&quot;locationsQuestion&quot;:&quot;What is your preferred work location?&quot;,&quot;requirementsHtml&quot;:null,&quot;sharingDescription&quot;:&quot;Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w&quot;,&quot;sharingImage&quot;:null,&quot;sharingImageHeight&quot;:null,&quot;sharingImageWidth&quot;:null,&quot;sharingTitle&quot;:&quot;Copywriter Talent Pool&quot;,&quot;state&quot;:&quot;New York&quot;,&quot;title&quot;:&quot;Copywriter Talent Pool&quot;}}}],&quot;page&quot;:{&quot;id&quot;:79071,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Careers homepage&quot;,&quot;position&quot;:1,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:251668,&quot;revision&quot;:{&quot;id&quot;:251668,&quot;insertedAt&quot;:&quot;2021-10-19T23:22:49Z&quot;,&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;header&quot;:null,&quot;name&quot;:null,&quot;settings&quot;:{&quot;contentPadding&quot;:&quot;none&quot;,&quot;header&quot;:null,&quot;isHeaderOn&quot;:false,&quot;layout&quot;:&quot;single-column&quot;,&quot;singleColumnLayout&quot;:{&quot;columnAlignment&quot;:&quot;left&quot;,&quot;columnWidth&quot;:12},&quot;textAlignment&quot;:&quot;center&quot;,&quot;textBackgroundColor&quot;:null,&quot;twoColumnLayout&quot;:{&quot;columnGap&quot;:&quot;large&quot;,&quot;columnRatio&quot;:&quot;1:1&quot;,&quot;stretchBackgroundEnabled&quot;:false,&quot;verticalAlignment&quot;:&quot;top&quot;}},&quot;theme&quot;:{&quot;actionColor&quot;:&quot;#fff&quot;,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:{&quot;height&quot;:834,&quot;imageId&quot;:7621,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/HcU/sWb17AUkqGgp.png&quot;,&quot;width&quot;:2288},&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:&quot;image&quot;,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;contentVerticalAlignment&quot;:&quot;center&quot;,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:&quot;#fff&quot;,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:true,&quot;isMinHeightOn&quot;:true,&quot;minHeight&quot;:&quot;medium&quot;,&quot;paddingBottom&quot;:&quot;large&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:&quot;#fff&quot;,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;translations&quot;:{&quot;en&quot;:{&quot;firstColumn&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;type&quot;:&quot;h1&quot;}]},&quot;secondColumn&quot;:{&quot;body&quot;:[],&quot;image&quot;:null}}},&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;e7405c08-6f63-4915-adcf-f85bb4aa397a&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Current openings&quot;}],&quot;type&quot;:&quot;h2&quot;}]}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;areFiltersOn&quot;:null,&quot;areGroupsOn&quot;:false,&quot;areTabsOn&quot;:false,&quot;cardsLayoutSettings&quot;:{&quot;areLanguagesOn&quot;:null,&quot;areTagsOn&quot;:null,&quot;backgroundColor&quot;:null,&quot;buttonPosition&quot;:&quot;aside&quot;,&quot;buttonText&quot;:null,&quot;columns&quot;:2,&quot;gap&quot;:&quot;medium&quot;,&quot;innerPadding&quot;:null,&quot;isButtonOn&quot;:true,&quot;isDepartmentOn&quot;:null,&quot;isLocationCityOn&quot;:null,&quot;isLocationCountryOn&quot;:null,&quot;isLocationNameOn&quot;:null,&quot;isLocationNoteOn&quot;:null,&quot;isLocationOn&quot;:null,&quot;isLocationRemoteOn&quot;:null,&quot;isLocationStateOn&quot;:null,&quot;isLocationStreetOn&quot;:null,&quot;isSalaryOn&quot;:null,&quot;titleSize&quot;:&quot;regular&quot;},&quot;filtersSettings&quot;:{&quot;defaultCountriesPerLanguage&quot;:[],&quot;defaultJobLanguagesPerPageLanguage&quot;:[],&quot;isCityFilterOn&quot;:true,&quot;isCountryFilterOn&quot;:true,&quot;isDepartmentFilterOn&quot;:false,&quot;isHeadingOn&quot;:true,&quot;isLanguageFilterOn&quot;:null,&quot;isRemoteFilterOn&quot;:null,&quot;isSearchOn&quot;:true,&quot;isStateFilterOn&quot;:false,&quot;isTagFilterOn&quot;:false,&quot;layout&quot;:&quot;boxed&quot;,&quot;position&quot;:&quot;top&quot;},&quot;groupsSettings&quot;:{&quot;groupBy&quot;:null,&quot;jobCounterVariant&quot;:null,&quot;position&quot;:null},&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:null,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:null,&quot;horizontalLayoutWidth&quot;:null,&quot;isBackgroundStretchOn&quot;:null,&quot;isCustomColored&quot;:null,&quot;padding&quot;:null,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:null,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:null,&quot;verticalLayoutWidth&quot;:null},&quot;isHeaderOn&quot;:true,&quot;isPaginationOn&quot;:null,&quot;layout&quot;:&quot;table&quot;,&quot;paginationSettings&quot;:null,&quot;prefiltersSettings&quot;:null,&quot;sortBy&quot;:null,&quot;tableLayoutSettings&quot;:{&quot;buttonText&quot;:null,&quot;isButtonOn&quot;:true,&quot;isDepartmentColumnOn&quot;:null,&quot;isLanguagesColumnOn&quot;:null,&quot;isLocationCityOn&quot;:null,&quot;isLocationColumnOn&quot;:false,&quot;isLocationCountryOn&quot;:null,&quot;isLocationNameOn&quot;:null,&quot;isLocationNoteOn&quot;:null,&quot;isLocationRemoteOn&quot;:null,&quot;isLocationStateOn&quot;:null,&quot;isLocationStreetOn&quot;:null,&quot;isSalaryColumnOn&quot;:null,&quot;isTagsColumnOn&quot;:null,&quot;spacing&quot;:&quot;spacious&quot;},&quot;tabsSettings&quot;:{&quot;jobCounterVariant&quot;:null,&quot;position&quot;:&quot;top&quot;,&quot;size&quot;:&quot;regular&quot;,&quot;tabBy&quot;:null}},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:null,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:&quot;top&quot;,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:true,&quot;minHeight&quot;:&quot;small&quot;,&quot;paddingBottom&quot;:&quot;large&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;OfferList&quot;,&quot;uuid&quot;:&quot;c88dea0d-b17f-4245-a020-9167e1e2bac0&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Our Philosophy&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We have a lot of fun together, something we consider to be really important. The creative process isn’t easy, but enjoying the journey is something we do well. We love what we do, and we think you’ll love working with us.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;image&quot;:{&quot;image&quot;:{&quot;height&quot;:1080,&quot;imageId&quot;:8800,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/ImA/Z18mPRgadPTx.jpeg&quot;,&quot;width&quot;:1080},&quot;translations&quot;:{&quot;en&quot;:{&quot;alt&quot;:&quot;some text&quot;}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;customImageWidth&quot;:100,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;left&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/2&quot;,&quot;isBackgroundStretchOn&quot;:true,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;extra-large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;left&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;center&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;horizontalAlignment&quot;:&quot;center&quot;,&quot;imageWidth&quot;:&quot;custom&quot;,&quot;isHeaderOn&quot;:true},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;small&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;fb8d4333-6abd-414e-aa18-d639f3f169ef&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;Our Clients&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;From powerhouses like the Brooklyn Navy Yard, Sesame Workshop, Vital Strategies, and Columbia University, to global movers and shakers like The American Cancer Society, United Nations, the International Rescue Committee, UNICEF, and Women’s Refugee Commission, we’ve worked together to solve some big problems and increase their impact.&quot;}],&quot;type&quot;:&quot;p&quot;}]}}},&quot;image&quot;:{&quot;image&quot;:{&quot;height&quot;:1080,&quot;imageId&quot;:8801,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/ImE/pqy0lEe95RqO.jpeg&quot;,&quot;width&quot;:1080},&quot;translations&quot;:{&quot;en&quot;:{&quot;alt&quot;:&quot;some text&quot;}}},&quot;name&quot;:null,&quot;settings&quot;:{&quot;customImageWidth&quot;:100,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;right&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/2&quot;,&quot;isBackgroundStretchOn&quot;:true,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;extra-large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;left&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;center&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;horizontalAlignment&quot;:&quot;center&quot;,&quot;imageWidth&quot;:&quot;custom&quot;,&quot;isHeaderOn&quot;:true},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;medium&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;c316b05d-aac8-4c48-995f-5b177342df19&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:null,&quot;name&quot;:null,&quot;settings&quot;:{&quot;contentPadding&quot;:&quot;small&quot;,&quot;header&quot;:null,&quot;isHeaderOn&quot;:false,&quot;layout&quot;:&quot;single-column&quot;,&quot;singleColumnLayout&quot;:{&quot;columnAlignment&quot;:&quot;center&quot;,&quot;columnWidth&quot;:12},&quot;textAlignment&quot;:&quot;left&quot;,&quot;textBackgroundColor&quot;:null,&quot;twoColumnLayout&quot;:{&quot;columnGap&quot;:&quot;small&quot;,&quot;columnRatio&quot;:&quot;1:1&quot;,&quot;stretchBackgroundEnabled&quot;:false,&quot;verticalAlignment&quot;:&quot;center&quot;}},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;translations&quot;:{&quot;en&quot;:{&quot;firstColumn&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;link&quot;:{&quot;target&quot;:&quot;_self&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;/&quot;},&quot;type&quot;:&quot;a&quot;},{&quot;text&quot;:&quot;Join a team of kind, curious, and empathetic individuals&quot;}],&quot;type&quot;:&quot;h3&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Radish Lab is a creative agency that believes that good design can help solve big challenges. We partner with organizations that are looking to create greater impact in their work and the world around them.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We believe good design is clear, simple, and engaging. And we believe that good design has the power to move you.We focus on helping social change projects and organizations tell compelling digital stories, deeply engage their audiences, and apply smart creative and technical solutions to some pretty impressive challenges.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;With offices in Brooklyn and Berlin, we love helping our clients create and tell compelling visual stories. &quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Radish Lab is also a certified B Corporation, which means we’re held accountable for meeting the highest standards of overall social and environmental performance, transparency and accountability.&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;&quot;}],&quot;type&quot;:&quot;p&quot;}]},&quot;secondColumn&quot;:{&quot;body&quot;:[],&quot;image&quot;:null}}},&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;f4523764-61b1-476e-9c60-90a3171bc222&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;SELECTED CLIENTS&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;We partner with organizations, activists and optimists. Here’s a handful we’ve already helped.&quot;}],&quot;type&quot;:&quot;h3&quot;}]}}},&quot;items&quot;:[{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8792,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilg/KFkAhPsAE6m7.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8793,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilk/lVkUsYEyvKky.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8794,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilo/S5EkxjRNYf4U.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8795,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ils/UcXAqrsyzCFC.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8796,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Ilw/5vZK251ADpLK.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8797,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il0/mJUUpYFqt7ny.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8798,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il4/J3g5SeRl41JZ.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null},{&quot;image&quot;:{&quot;height&quot;:255,&quot;imageId&quot;:8799,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/Il8/pXhL2Ip7Ng1z.png&quot;,&quot;width&quot;:255},&quot;translations&quot;:{},&quot;video&quot;:null}],&quot;name&quot;:null,&quot;settings&quot;:{&quot;borderRadius&quot;:0,&quot;carousel&quot;:null,&quot;columnCount&quot;:4,&quot;gap&quot;:&quot;small&quot;,&quot;grid&quot;:{&quot;emphasizedItems&quot;:[{&quot;columnCount&quot;:2,&quot;settings&quot;:[{&quot;columnIndex&quot;:0,&quot;rowIndex&quot;:1},{&quot;columnIndex&quot;:0,&quot;rowIndex&quot;:2}]},{&quot;columnCount&quot;:3,&quot;settings&quot;:[{&quot;columnIndex&quot;:1,&quot;rowIndex&quot;:1},{&quot;columnIndex&quot;:1,&quot;rowIndex&quot;:2},{&quot;columnIndex&quot;:2,&quot;rowIndex&quot;:0}]}]},&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;medium&quot;,&quot;headerPosition&quot;:&quot;top&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/4&quot;,&quot;isBackgroundStretchOn&quot;:false,&quot;isCustomColored&quot;:false,&quot;padding&quot;:&quot;none&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;center&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;top&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;isHeaderOn&quot;:true,&quot;isLightboxOn&quot;:null,&quot;layout&quot;:&quot;grid&quot;,&quot;masonry&quot;:{&quot;heightSettings&quot;:{&quot;firstRow&quot;:[{&quot;columnIndex&quot;:1,&quot;heightMultiplier&quot;:1.0},{&quot;columnIndex&quot;:3,&quot;heightMultiplier&quot;:1.5}],&quot;lastRow&quot;:[{&quot;columnIndex&quot;:0,&quot;heightMultiplier&quot;:1.0},{&quot;columnIndex&quot;:1,&quot;heightMultiplier&quot;:1.0}]},&quot;widthSettings&quot;:[{&quot;columnCount&quot;:2,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[4,8],&quot;rowIndex&quot;:0}]},{&quot;columnCount&quot;:3,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[3,4,5],&quot;rowIndex&quot;:0}]},{&quot;columnCount&quot;:4,&quot;columnSizes&quot;:[{&quot;columnProportions&quot;:[4,2,2,4],&quot;rowIndex&quot;:0}]}]},&quot;rowAlignment&quot;:&quot;center&quot;},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:&quot;center&quot;,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;small&quot;,&quot;paddingTop&quot;:&quot;large&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;ImageCollection&quot;,&quot;uuid&quot;:&quot;6808b50d-8984-4888-8f76-4fbff8bb3e67&quot;},{&quot;anchor&quot;:null,&quot;header&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;body&quot;:[{&quot;children&quot;:[{&quot;text&quot;:&quot;OUR OFFICE&quot;}],&quot;type&quot;:&quot;p&quot;},{&quot;children&quot;:[{&quot;text&quot;:&quot;Brooklyn – DUMBO&quot;}],&quot;type&quot;:&quot;h3&quot;}]}}},&quot;map&quot;:{&quot;markers&quot;:[{&quot;address&quot;:&quot;20 Jay Street, Brooklyn, New York 11201, United States&quot;,&quot;latitude&quot;:&quot;40.704097&quot;,&quot;longitude&quot;:&quot;-73.98688&quot;,&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:&quot;&quot;,&quot;title&quot;:&quot;Brooklyn&quot;}}}]},&quot;name&quot;:null,&quot;settings&quot;:{&quot;areMapControlsOn&quot;:true,&quot;gap&quot;:&quot;small&quot;,&quot;header&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;gap&quot;:&quot;large&quot;,&quot;headerPosition&quot;:&quot;top&quot;,&quot;headingColor&quot;:null,&quot;horizontalAlignment&quot;:&quot;left&quot;,&quot;horizontalLayoutWidth&quot;:&quot;1/4&quot;,&quot;isBackgroundStretchOn&quot;:false,&quot;isCustomColored&quot;:null,&quot;padding&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textAlignment&quot;:&quot;center&quot;,&quot;textColor&quot;:null,&quot;verticalAlignment&quot;:&quot;top&quot;,&quot;verticalLayoutWidth&quot;:&quot;full&quot;},&quot;isHeaderOn&quot;:true,&quot;mapAlignment&quot;:&quot;center&quot;,&quot;mapHeight&quot;:&quot;medium&quot;,&quot;mapTilesStyle&quot;:&quot;streets-v11&quot;,&quot;mapWidth&quot;:12},&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:&quot;center&quot;,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:&quot;cover&quot;,&quot;backgroundImageVerticalAlignment&quot;:&quot;center&quot;,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:false,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:&quot;container&quot;,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:&quot;medium&quot;,&quot;paddingTop&quot;:&quot;medium&quot;,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null},&quot;type&quot;:&quot;Map&quot;,&quot;uuid&quot;:&quot;cb09dc8f-0334-4c29-9278-7141395f4bf7&quot;}]},&quot;slug&quot;:&quot;homepage&quot;,&quot;status&quot;:&quot;published&quot;,&quot;theme&quot;:{&quot;actionColor&quot;:&quot;#000000&quot;,&quot;backgroundColor&quot;:&quot;#fff&quot;,&quot;buttonFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;buttonFontStyle&quot;:null,&quot;buttonFontTransform&quot;:null,&quot;buttonFontWeight&quot;:&quot;600&quot;,&quot;default&quot;:true,&quot;footer&quot;:{&quot;areLinksOn&quot;:false,&quot;areSocialLinksOn&quot;:false,&quot;isFooterOn&quot;:null,&quot;languagePicker&quot;:null,&quot;links&quot;:[],&quot;logo&quot;:null,&quot;logoLink&quot;:null,&quot;logoMaxHeight&quot;:null,&quot;logoWithAlt&quot;:null,&quot;socialLinks&quot;:[],&quot;theme&quot;:{&quot;actionColor&quot;:null,&quot;backgroundColor&quot;:null,&quot;backgroundImage&quot;:null,&quot;backgroundImageHorizontalAlignment&quot;:null,&quot;backgroundImageOverlayColor&quot;:null,&quot;backgroundImageSize&quot;:null,&quot;backgroundImageVerticalAlignment&quot;:null,&quot;backgroundLayers&quot;:[],&quot;backgroundMediaType&quot;:null,&quot;backgroundMigrated&quot;:null,&quot;backgroundVideo&quot;:null,&quot;backgroundVideoOverlayColor&quot;:null,&quot;contentBoundary&quot;:null,&quot;contentVerticalAlignment&quot;:null,&quot;customMinHeight&quot;:null,&quot;headingColor&quot;:null,&quot;headingFontFamily&quot;:null,&quot;headingFontWeight&quot;:null,&quot;isBackgroundOn&quot;:null,&quot;isMinHeightOn&quot;:null,&quot;minHeight&quot;:null,&quot;paddingBottom&quot;:null,&quot;paddingTop&quot;:null,&quot;primaryButtonTextColor&quot;:null,&quot;textColor&quot;:null,&quot;textFontFamily&quot;:null,&quot;textFontWeight&quot;:null}},&quot;headingColor&quot;:&quot;#000000&quot;,&quot;headingFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;headingFontStyle&quot;:null,&quot;headingFontTransform&quot;:null,&quot;headingFontWeight&quot;:&quot;600&quot;,&quot;id&quot;:39544,&quot;name&quot;:&quot;Default&quot;,&quot;navigation&quot;:{&quot;button&quot;:null,&quot;colorSchemeSource&quot;:null,&quot;contentBoundary&quot;:null,&quot;fixedNavigationLogo&quot;:null,&quot;fixedNavigationLogoWithAlt&quot;:null,&quot;fixedNavigationTheme&quot;:null,&quot;fixedNavigationType&quot;:null,&quot;isFixed&quot;:null,&quot;languagePicker&quot;:null,&quot;layout&quot;:null,&quot;links&quot;:[{&quot;items&quot;:[],&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null,&quot;label&quot;:&quot;Company website&quot;,&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:null,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.radishlab.com/&quot;},&quot;url&quot;:null}},&quot;type&quot;:null}],&quot;logo&quot;:{&quot;height&quot;:312,&quot;imageId&quot;:10003,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/JxM/erKO0TGNyJ6_.png&quot;,&quot;width&quot;:1118},&quot;logoLink&quot;:{&quot;translations&quot;:{&quot;en&quot;:{&quot;description&quot;:null,&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:79071,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:null,&quot;type&quot;:&quot;page&quot;,&quot;url&quot;:null}}}},&quot;logoMaxHeight&quot;:null,&quot;logoWithAlt&quot;:null,&quot;socialLinks&quot;:[{&quot;translations&quot;:{&quot;en&quot;:{&quot;link&quot;:{&quot;email&quot;:null,&quot;offerId&quot;:null,&quot;pageId&quot;:null,&quot;phoneNumber&quot;:null,&quot;sectionUuid&quot;:null,&quot;target&quot;:&quot;_blank&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;https://www.instagram.com/radishlab/&quot;},&quot;url&quot;:null}},&quot;type&quot;:&quot;instagram&quot;}],&quot;theme&quot;:null},&quot;pageIds&quot;:[79072,281476,79071],&quot;primaryButtonTextColor&quot;:null,&quot;recruiteeBranding&quot;:null,&quot;textColor&quot;:&quot;#000000&quot;,&quot;textFontFamily&quot;:&quot;system_sans_serif&quot;,&quot;textFontSize&quot;:null,&quot;textFontStyle&quot;:null,&quot;textFontTransform&quot;:null,&quot;textFontWeight&quot;:&quot;400&quot;},&quot;translations&quot;:{},&quot;type&quot;:&quot;homepage&quot;,&quot;visibility&quot;:&quot;public&quot;},&quot;pages&quot;:[{&quot;id&quot;:79071,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Careers homepage&quot;,&quot;position&quot;:1,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:251668,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;e7405c08-6f63-4915-adcf-f85bb4aa397a&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;OfferList&quot;,&quot;uuid&quot;:&quot;c88dea0d-b17f-4245-a020-9167e1e2bac0&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;fb8d4333-6abd-414e-aa18-d639f3f169ef&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Image&quot;,&quot;uuid&quot;:&quot;c316b05d-aac8-4c48-995f-5b177342df19&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Text&quot;,&quot;uuid&quot;:&quot;f4523764-61b1-476e-9c60-90a3171bc222&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;ImageCollection&quot;,&quot;uuid&quot;:&quot;6808b50d-8984-4888-8f76-4fbff8bb3e67&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Map&quot;,&quot;uuid&quot;:&quot;cb09dc8f-0334-4c29-9278-7141395f4bf7&quot;}]},&quot;slug&quot;:&quot;homepage&quot;,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;homepage&quot;,&quot;visibility&quot;:&quot;public&quot;},{&quot;id&quot;:79072,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;Offer details&quot;,&quot;position&quot;:2,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:250726,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;OfferHeadline&quot;,&quot;uuid&quot;:&quot;a8e9c04b-733b-4245-b54f-45e388a6d718&quot;},{&quot;anchor&quot;:null,&quot;type&quot;:&quot;Offer&quot;,&quot;uuid&quot;:&quot;fd8097f3-6dc5-4dff-96ab-ff3e71e23837&quot;}]},&quot;slug&quot;:null,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;offer_details&quot;,&quot;visibility&quot;:&quot;public&quot;},{&quot;id&quot;:281476,&quot;jobsVisibility&quot;:&quot;published&quot;,&quot;langCodes&quot;:[&quot;en&quot;],&quot;locked&quot;:true,&quot;name&quot;:&quot;We couldn&#39;t find this job&quot;,&quot;position&quot;:0,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publishedRevisionId&quot;:409485,&quot;revision&quot;:{&quot;sections&quot;:[{&quot;anchor&quot;:null,&quot;type&quot;:&quot;JobNotFound&quot;,&quot;uuid&quot;:null}]},&quot;slug&quot;:null,&quot;status&quot;:&quot;published&quot;,&quot;translations&quot;:{},&quot;type&quot;:&quot;job_not_found&quot;,&quot;visibility&quot;:&quot;public&quot;}],&quot;sentryEnv&quot;:&quot;production&quot;,&quot;site&quot;:{&quot;advancedSettings&quot;:{&quot;internalJobsListing&quot;:&quot;disabled&quot;},&quot;awliApiKey&quot;:null,&quot;awliIntegrationContext&quot;:null,&quot;captcha&quot;:&quot;invisible&quot;,&quot;careersAnalyticsEnabled&quot;:true,&quot;companyLangCodes&quot;:[&quot;en&quot;],&quot;cookieConsentEnabled&quot;:false,&quot;customCss&quot;:null,&quot;customHtmlBody&quot;:null,&quot;customHtmlHead&quot;:null,&quot;defaultOgImageUrl&quot;:&quot;https://careers.recruiteecdn.com/image/upload/share_image_w6am4m.png&quot;,&quot;domainActivated&quot;:false,&quot;eeo&quot;:{&quot;isEnabled&quot;:false,&quot;kind&quot;:&quot;eeo&quot;},&quot;externalId&quot;:53295,&quot;host&quot;:&quot;radishlab.recruitee.com&quot;,&quot;id&quot;:39590,&quot;kununuHash&quot;:null,&quot;kununuLink&quot;:null,&quot;langCodes&quot;:[&quot;en&quot;],&quot;migrationDate&quot;:null,&quot;name&quot;:&quot;Radish Lab&quot;,&quot;primaryLangCode&quot;:&quot;en&quot;,&quot;publicTranslations&quot;:{&quot;en&quot;:{&quot;shareFilteredJobsList&quot;:&quot;Share filtered jobs list&quot;,&quot;allCities&quot;:&quot;All cities&quot;,&quot;applicationSuccessDescription&quot;:&quot;Your application has been successfully submitted!&quot;,&quot;carouselPreviousSlideLabel&quot;:&quot;Previous slide&quot;,&quot;allDepartments&quot;:&quot;All departments&quot;,&quot;remote&quot;:&quot;Remote&quot;,&quot;stateFilterLabel&quot;:&quot;Select states/regions to filter offers by&quot;,&quot;allLanguages&quot;:&quot;All languages&quot;,&quot;xingCvNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;searchOffersLabel&quot;:&quot;Enter search query to filter offers by&quot;,&quot;cvFormatAllowedExtensions&quot;:&quot;Accepted files: PDF, DOC, DOCX, JPEG and PNG up to 50MB.&quot;,&quot;workModelFilterLabel&quot;:&quot;Select work model to filter offers by&quot;,&quot;shareJob&quot;:&quot;Share job&quot;,&quot;tooLargeFile&quot;:&quot;This file is too large&quot;,&quot;languages&quot;:&quot;Available languages&quot;,&quot;skipToContent&quot;:&quot;Skip to content&quot;,&quot;xingNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;departmentFilterLabel&quot;:&quot;Select departments to filter offers by&quot;,&quot;dragAndDrop&quot;:&quot;or drag and drop here&quot;,&quot;xingClearProfileData&quot;:&quot;Clear profile data&quot;,&quot;clearTextAndUploadFile&quot;:&quot;Clear text and upload a file instead&quot;,&quot;xJobs&quot;:&quot;%{jobsCount} jobs&quot;,&quot;viewJob&quot;:&quot;View job&quot;,&quot;jobDoesntExist&quot;:&quot;This job doesn’t exist or was removed.&quot;,&quot;emailPlaceholder&quot;:&quot;Your email address&quot;,&quot;offerTitle&quot;:&quot;Job title&quot;,&quot;textingConsent&quot;:&quot;I consent to be contacted via text messages for this and any other job within %{companyName}.&quot;,&quot;phonePlaceholder&quot;:&quot;Your phone number&quot;,&quot;applicationSuccessHeading&quot;:&quot;All done!&quot;,&quot;xMore&quot;:&quot;%{count} more&quot;,&quot;orApplyWith&quot;:&quot;or&quot;,&quot;carouselNextSlideLabel&quot;:&quot;Next slide&quot;,&quot;insertEmailAddress&quot;:&quot;This email address is invalid. Please enter a valid email address (for example, name@example.com).&quot;,&quot;yesAnswer&quot;:&quot;Yes&quot;,&quot;hybrid&quot;:&quot;Hybrid&quot;,&quot;perYear&quot;:&quot;%{range} per year&quot;,&quot;applicationSuccessButtonLabel&quot;:&quot;Other jobs&quot;,&quot;locationNoteTooltip&quot;:&quot;Location note tooltip&quot;,&quot;agreementsLabel&quot;:&quot;Legal Agreements&quot;,&quot;phoneLabel&quot;:&quot;Phone number&quot;,&quot;emptyPage&quot;:&quot;This page is empty&quot;,&quot;city&quot;:&quot;City&quot;,&quot;clearFilters&quot;:&quot;Clear&quot;,&quot;extensionError&quot;:&quot;allowed file types&quot;,&quot;offerListNoOffers&quot;:&quot;Currently we don&#39;t have any open positions.&quot;,&quot;salary&quot;:&quot;Salary&quot;,&quot;personalInformationHint&quot;:&quot;Fill out the information below&quot;,&quot;insertValidPhoneNumber&quot;:&quot;This phone number is invalid. Please enter a valid phone number, including the country calling code.&quot;,&quot;applyForm&quot;:&quot;Application&quot;,&quot;coverLetterButtonWriteHere&quot;:&quot;Write it here instead&quot;,&quot;international&quot;:&quot;International&quot;,&quot;enterText&quot;:&quot;Enter text&quot;,&quot;linkedInNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;coverLetterLabel&quot;:&quot;Cover letter&quot;,&quot;languageFilterLabel&quot;:&quot;Select languages to filter offers by&quot;,&quot;requiredFieldsDescription&quot;:&quot;All fields marked with * are required.&quot;,&quot;questionsHint&quot;:&quot;Please fill in additional questions&quot;,&quot;cvLabel&quot;:&quot;CV or resume&quot;,&quot;showFiltersButtonText&quot;:&quot;Show filters&quot;,&quot;imageCollectionEmptyDescription&quot;:&quot;Image collection is empty&quot;,&quot;cvHint&quot;:&quot;Upload your CV or resume file&quot;,&quot;jobNotFound&quot;:&quot;We couldn’t find this job&quot;,&quot;tooManyFiles&quot;:&quot;Too many files&quot;,&quot;questionsLabel&quot;:&quot;Questions&quot;,&quot;showMoreJobs&quot;:&quot;Show more jobs&quot;,&quot;send&quot;:&quot;Send&quot;,&quot;location&quot;:&quot;Location&quot;,&quot;workModel&quot;:&quot;Work model&quot;,&quot;applied&quot;:&quot;Applied&quot;,&quot;allStates&quot;:&quot;All states/regions&quot;,&quot;offerListNoOffersMatchingFilters&quot;:&quot;No open positions matching selected filters.&quot;,&quot;offerListFiltersHeading&quot;:&quot;Filters&quot;,&quot;copied&quot;:&quot;Copied&quot;,&quot;tags&quot;:&quot;Tags&quot;,&quot;showingXOfY&quot;:&quot;Showing %{visibleJobsCount} of %{jobsCount}&quot;,&quot;coverLetterButtonClearAndUpload&quot;:&quot;Clear and upload a cover letter instead&quot;,&quot;coverLetterHint&quot;:&quot;Insert your cover letter here&quot;,&quot;applyWithIndeed&quot;:&quot;Apply with Indeed&quot;,&quot;fieldRequired&quot;:&quot;This field is required and can not be left empty.&quot;,&quot;details&quot;:&quot;Details&quot;,&quot;clearDateButton&quot;:&quot;Clear&quot;,&quot;onSite&quot;:&quot;On-site&quot;,&quot;department&quot;:&quot;Department&quot;,&quot;tag&quot;:&quot;Tag&quot;,&quot;perHour&quot;:&quot;%{range} per hour&quot;,&quot;namePlaceholder&quot;:&quot;Full name&quot;,&quot;uploadFile&quot;:&quot;Upload a file&quot;,&quot;hideFiltersButtonText&quot;:&quot;Hide filters&quot;,&quot;applyWithXing&quot;:&quot;Apply With XING&quot;,&quot;close&quot;:&quot;Close&quot;,&quot;homepage&quot;:&quot;Homepage&quot;,&quot;countryFilterLabel&quot;:&quot;Select countries to filter offers by&quot;,&quot;offerRequirements&quot;:&quot;Job requirements&quot;,&quot;offerDescription&quot;:&quot;Job description&quot;,&quot;present&quot;:&quot;Present&quot;,&quot;noAnswer&quot;:&quot;No&quot;,&quot;allTags&quot;:&quot;All tags&quot;,&quot;coverLetterHintFileUpload&quot;:&quot;Upload your cover letter&quot;,&quot;country&quot;:&quot;Country&quot;,&quot;changeFile&quot;:&quot;Change file&quot;,&quot;shareTo&quot;:&quot;Share to&quot;,&quot;nameLabel&quot;:&quot;Full name&quot;,&quot;filenameBlankError&quot;:&quot;Filename can&#39;t be blank&quot;,&quot;link&quot;:&quot;Link&quot;,&quot;offerListTabsLabel&quot;:&quot;Select tab to filter offers by&quot;,&quot;searchOffers&quot;:&quot;Search offers...&quot;,&quot;play&quot;:&quot;Play&quot;,&quot;goToHomepage&quot;:&quot;Go to homepage&quot;,&quot;remoteJob&quot;:&quot;Remote job&quot;,&quot;linkedInCvNotice&quot;:&quot;You can also upload your CV or resume file.&quot;,&quot;noDepartment&quot;:&quot;No department&quot;,&quot;unsafeError&quot;:&quot;is unsafe&quot;,&quot;copy&quot;:&quot;Copy&quot;,&quot;linkedInClearProfileData&quot;:&quot;Clear profile data&quot;,&quot;invalidError&quot;:&quot;is invalid&quot;,&quot;applyWith&quot;:&quot;Apply with&quot;,&quot;blankError&quot;:&quot;can&#39;t be blank&quot;,&quot;phoneCallingCodeLabel&quot;:&quot;Select country calling code&quot;,&quot;photoLabel&quot;:&quot;Photo&quot;,&quot;allCountries&quot;:&quot;All countries&quot;,&quot;removeFile&quot;:&quot;Remove&quot;,&quot;invalidFileType&quot;:&quot;Invalid file type&quot;,&quot;tagFilterLabel&quot;:&quot;Select tags to filter offers by&quot;,&quot;emailLabel&quot;:&quot;Email address&quot;,&quot;apply&quot;:&quot;Apply&quot;,&quot;offerListNoOffersMatchingPrefilters&quot;:&quot;No open positions.&quot;,&quot;departments&quot;:&quot;Departments&quot;,&quot;moreLocationsTooltip&quot;:&quot;More locations tooltip&quot;,&quot;perMonth&quot;:&quot;%{range} per month&quot;,&quot;share&quot;:&quot;Share&quot;,&quot;skipToCookieConsent&quot;:&quot;Skip to Cookie Consent&quot;,&quot;photoFormatAllowedExtensions&quot;:&quot;Accepted files: PNG, JPG and JPEG up to 20MB.&quot;,&quot;textingConsentHeader&quot;:&quot;SMS consent&quot;,&quot;pageNavigationLabel&quot;:&quot;Page navigation&quot;,&quot;cityFilterLabel&quot;:&quot;Select cities to filter offers by&quot;,&quot;personalInformationLabel&quot;:&quot;My information&quot;,&quot;noState&quot;:&quot;No state/region&quot;,&quot;state&quot;:&quot;State&quot;,&quot;coverLetterFileAllowedFormats&quot;:&quot;We accept PDF, DOC, DOCX, JPG and PNG files.&quot;,&quot;coverLetterHintTextArea&quot;:&quot;Write your cover letter here&quot;,&quot;offerDetails&quot;:&quot;Job details&quot;}},&quot;redirectToCustomDomain&quot;:true,&quot;subdomain&quot;:&quot;radishlab&quot;,&quot;textingSettingsEnabled&quot;:false,&quot;translations&quot;:{&quot;en&quot;:{&quot;ogImage&quot;:{&quot;height&quot;:418,&quot;imageId&quot;:66150,&quot;url&quot;:&quot;https://careers.recruiteecdn.com/image/upload/production/images/AQJm/eTpqtQ6sZ9sc.jpeg&quot;,&quot;width&quot;:800}}},&quot;updatedAt&quot;:&quot;2024-07-27T22:05:18&quot;}}}"><div></div><div class="sc-q8cmux-0 gBDROR"><a class="sc-q8cmux-1 kJsRIK" href="#content" data-reach-skip-link="" data-reach-skip-nav-link="">Skip to content</a></div><div class="sc-73r8cv-1 ilRiFP"><div data-scroll-point="section-navigation"><div class="sc-z9o81a-0 kllnfT"><div class="sc-z9o81a-1 fsBFXt"><div data-cy="navigation-section-position" style="font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;color:#fff;background-color:rgba(0, 0, 0, 0)" class="sc-3k6t01-0 jLGbJs"><div data-cy="navigation-section-grid-container" class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-0 dYPHZW"><div class="sc-1aabq8s-0 sc-1aabq8s-1 kJLltb"><a class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo" href="/"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" data-cy="navigation-section-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></a><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 kpwRdG"><nav><ul class="sc-1aabq8s-2 sc-1aabq8s-3 sc-1xewqye-0 hdTF"><li class="sc-1aabq8s-4 kcKagb"><a data-cy="navigation-section-link-item" href="https://www.radishlab.com/" target="_blank" rel="noopener" class="sc-ir8rf5-0 dPcHAE">Company website</a></li><li class="sc-1aabq8s-4 kcKagb"><a data-cy="navigation-section-social-link-item" href="https://www.instagram.com/radishlab/" target="_blank" title="instagram" rel="noopener" class="sc-7glywv-0 hlNgLl"><span class="sc-1rd450u-0 bIScAX"><svg width="18" height="18" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></a></li></ul></nav></div></div><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-1 ciZwhu"><div class="sc-1aabq8s-0 sc-1aabq8s-1 sc-1hkznj2-0 cghDST"><a class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo" href="/"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" data-cy="navigation-section-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></a><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 sc-1hkznj2-1 guEbMs"><div class="sc-1tx5im8-0 iudIDi"><button aria-live="polite" type="button" aria-haspopup="true" aria-controls="menu" aria-label="Page navigation" data-reach-menu-button="" class="sc-s03za1-0 eDCgIN sc-1km6n6q-1 sc-1tu9xny-2 iPvmIC"><span class="sc-1rd450u-0 bIScAX"><svg height="12" width="18" viewBox="0 0 18 12"><path d="M0 12h18v-2H0v2Zm0-5h18V5H0v2Zm0-7v2h18V0H0Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg></span></button><div data-reach-menu="" data-reach-menu-popover="" hidden="" class="sc-1tu9xny-4 sc-1tx5im8-1 hBOHsL"><div role="menu" tabindex="-1" data-reach-menu-items="" id="menu" style="background-color:#fff" class="sc-1tu9xny-0 hLPFpI"><div role="none" tabindex="-1"><a role="menuitem" tabindex="-1" href="https://www.radishlab.com/" target="_blank" data-reach-menu-link="" data-reach-menu-item="" data-selected="" data-valuetext="" class="sc-1tu9xny-1 kZTElj">Company website</a></div><div role="none" tabindex="-1"><a role="menuitem" tabindex="-1" href="https://www.instagram.com/radishlab/" aria-label="instagram" target="_BLANK" rel="noopener" style="display:inline-flex" data-reach-menu-link="" data-reach-menu-item="" data-selected="" data-valuetext="" class="sc-1tu9xny-1 kZTElj"><span class="sc-1rd450u-0 bIScAX"><svg width="15" height="15" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></a></div></div></div></div></div></div></div></div></div></div></div></div><div id="content" data-reach-skip-nav-content=""></div><main class="sc-73r8cv-0 homvAg"><div data-scroll-point="section-text-e7405c08"><section class="sc-gfrfnr-0 gJxpwG custom-css-style-first-section custom-css-section-e7405c08" data-cy="section-background-wrapper" style="background-color:#fff"><div class="sc-gfrfnr-2 deOrHQ"><div class="sc-1oxti4r-0 ixGbOy"><img data-cy="section-background-image" role="presentation" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/HcU/sWb17AUkqGgp.png" alt="" class="sc-itprxg-0 UZqcu"/></div><div class="sc-gfrfnr-1 iVfIXi custom-css-style-first-section-background"></div></div><div class="sc-18h7are-0 ebVyJP"><div role="presentation" inert="true" aria-hidden="true" class="sc-lqj8ks-0 hfKXfE"><div style="font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;color:#fff;background-color:rgba(0, 0, 0, 0)" class="sc-3k6t01-0 jLGbJs"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-0 dYPHZW"><div class="sc-1aabq8s-0 sc-1aabq8s-1 kJLltb"><div class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></div><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 kpwRdG"><nav><ul class="sc-1aabq8s-2 sc-1aabq8s-3 sc-1xewqye-0 hdTF"><li class="sc-1aabq8s-4 kcKagb"><div class="sc-ir8rf5-0 dPcHAE">Company website</div></li><li class="sc-1aabq8s-4 kcKagb"><div title="instagram" class="sc-7glywv-0 hlNgLl"><span class="sc-1rd450u-0 bIScAX"><svg width="18" height="18" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 26 26"><path fill-rule="evenodd" clip-rule="evenodd" d="M13 0C9.46942 0 9.02633 0.0151667 7.63967 0.078C6.56151 0.0997708 5.49484 0.304167 4.485 0.6825C3.62128 1.01649 2.83688 1.52726 2.18207 2.18207C1.52726 2.83688 1.01649 3.62128 0.6825 4.485C0.304047 5.49518 0.0996487 6.56222 0.078 7.64075C0.0151667 9.02742 0 9.46833 0 13C0 16.5317 0.0151667 16.9737 0.078 18.3603C0.0997708 19.4385 0.304167 20.5052 0.6825 21.515C1.01649 22.3787 1.52726 23.1631 2.18207 23.8179C2.83688 24.4727 3.62128 24.9835 4.485 25.3175C5.49518 25.696 6.56222 25.9004 7.64075 25.922C9.02742 25.9848 9.46942 26 13 26C16.5306 26 16.9737 25.9848 18.3603 25.922C19.4389 25.9004 20.5059 25.696 21.5161 25.3175C22.3798 24.9835 23.1642 24.4727 23.819 23.8179C24.4738 23.1631 24.9846 22.3787 25.3186 21.515C25.6967 20.5048 25.9007 19.4377 25.922 18.3593C25.9848 16.9726 26 16.5317 26 13C26 9.46833 25.9848 9.02633 25.922 7.63967C25.9002 6.56151 25.6958 5.49484 25.3175 4.485C24.9835 3.62128 24.4727 2.83688 23.8179 2.18207C23.1631 1.52726 22.3787 1.01649 21.515 0.6825C20.5048 0.304416 19.4377 0.100385 18.3593 0.0790833C16.9726 0.0140833 16.5317 0 13 0ZM19.9398 7.62022C20.8014 7.62022 21.4998 6.92179 21.4998 6.06022C21.4998 5.19866 20.8014 4.50022 19.9398 4.50022C19.0783 4.50022 18.3798 5.19866 18.3798 6.06022C18.3798 6.92179 19.0783 7.62022 19.9398 7.62022ZM9.29129 7.44954C10.3891 6.71602 11.6797 6.32451 13 6.32451C14.7705 6.32451 16.4684 7.02782 17.7203 8.27972C18.9722 9.53162 19.6755 11.2296 19.6755 13C19.6755 14.3203 19.284 15.6109 18.5505 16.7087C17.817 17.8065 16.7744 18.6621 15.5546 19.1674C14.3348 19.6726 12.9926 19.8048 11.6977 19.5472C10.4028 19.2897 9.21329 18.6539 8.27971 17.7203C7.34612 16.7867 6.71034 15.5973 6.45277 14.3023C6.19519 13.0074 6.32739 11.6652 6.83264 10.4454C7.3379 9.22562 8.19351 8.18305 9.29129 7.44954ZM10.5925 16.603C11.3051 17.0792 12.1429 17.3333 13 17.3333C14.1493 17.3333 15.2515 16.8768 16.0641 16.0641C16.8768 15.2515 17.3333 14.1493 17.3333 13C17.3333 12.143 17.0792 11.3052 16.603 10.5925C16.1269 9.87993 15.4501 9.32452 14.6583 8.99654C13.8665 8.66856 12.9952 8.58274 12.1546 8.74994C11.314 8.91715 10.5419 9.32986 9.93587 9.93588C9.32984 10.5419 8.91713 11.314 8.74993 12.1546C8.58273 12.9952 8.66854 13.8665 8.99652 14.6583C9.3245 15.4501 9.87992 16.1269 10.5925 16.603Z" fill="currentColor"></path></svg></span></div></li></ul></nav></div></div><div style="min-height:80px;padding-top:20px;padding-bottom:20px" class="sc-1dj1hqi-2 sc-it5itd-1 ciZwhu"><div class="sc-1aabq8s-0 sc-1aabq8s-1 sc-1hkznj2-0 cghDST"><div class="sc-pxbyo9-0 QEQag custom-css-style-navigation-logo"><img class="sc-83wl6d-0 klfKrz custom-css-style-navigation-logo-image" alt="Radish Lab logo" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_400,c_limit/production/images/JxM/erKO0TGNyJ6_.png"/><span aria-hidden="true" class="sc-83wl6d-1 eNDDPg">Radish Lab</span><span style="border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;word-wrap:normal">Homepage</span></div><div width="16px" role="none" class="sc-1jf9qcy-0 gXycJU"></div></div><div class="sc-1aabq8s-0 sc-1hkznj2-1 guEbMs"><div class="sc-s03za1-0 jmbcoz sc-1tu9xny-3 cAzrSG"><span class="sc-1rd450u-0 bIScAX"><svg height="12" width="18" viewBox="0 0 18 12"><path d="M0 12h18v-2H0v2Zm0-5h18V5H0v2Zm0-7v2h18V0H0Z" fill="currentColor" fill-rule="evenodd" clip-rule="evenodd"></path></svg></span></div></div></div></div></div></div></div><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 guycoN"><div style="color:#fff;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><p class="sc-1we8l0o-2 dPLHJJ"></p></div></div></div></div></div></section></div><div data-scroll-point="section-jobs-c88dea0d"><section class="sc-gfrfnr-0 gQRcOO custom-css-section-c88dea0d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 bSaXtg"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 guycoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 bEnYHY"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h2 data-slate-node="element" class="sc-1npqnwg-2 sc-1npqnwg-3 eFVUhY slate-h2"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Current openings</span></span></span></h2></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div><div class="sc-4j8eof-0 dPfocN"><div data-testid="offer-list-grid" class="sc-1mxcttb-0 dWcJRW"><div class="sc-4j8eof-1 jFfmvQ"><div class="sc-4j8eof-2 iOxTuT"><output class="sc-1mxcttb-2 fDKnQQ"><div class="sc-1dywz0m-0 exQcZ"><div class="sc-1qe5ahw-0 ffHrMJ"><div class="sc-18rtkup-1 hhapWv"><table class="sc-18rtkup-0 bJoAoi"><thead><tr><th style="width:50%">Job title</th><th style="width:50%">Work model</th><th></th></tr></thead><tbody><tr><td><a href="/o/copywriter-talen-pool" class="sc-18rtkup-2 bqJcqI">Copywriter Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/copywriter-talen-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/design-talent-pool" class="sc-18rtkup-2 bqJcqI">Design Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/design-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/developer-talent-pool" class="sc-18rtkup-2 bqJcqI">Developer Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/developer-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr><tr><td><a href="/o/project-manager-talent-pool" class="sc-18rtkup-2 bqJcqI">Project Manager Talent Pool</a></td><td>Remote</td><td style="text-align:right"><a aria-live="off" href="/o/project-manager-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></td></tr></tbody></table></div></div></div><div class="sc-1dywz0m-1 gcbsVn"><div class="sc-465zle-0 brHqfD"><div class="sc-465zle-1 fTGeMR"><a href="/o/copywriter-talen-pool" class="sc-465zle-2 bCpqiX">Copywriter Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/copywriter-talen-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/design-talent-pool" class="sc-465zle-2 bCpqiX">Design Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/design-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/developer-talent-pool" class="sc-465zle-2 bCpqiX">Developer Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/developer-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div><div class="sc-465zle-1 fTGeMR"><a href="/o/project-manager-talent-pool" class="sc-465zle-2 bCpqiX">Project Manager Talent Pool</a><div class="sc-465zle-3 gkgGSG"><div class="sc-465zle-4 jvvolj"><span class="sc-1rd450u-0 bIScAX"><svg height="20" width="20" viewBox="0 0 20 20"><path fill="currentColor" d="M5 15.833h2.5v-5h5v5H15v-7.5l-5-3.75-5 3.75v7.5ZM3.333 17.5v-10L10 2.5l6.667 5v10h-5.834v-5H9.168v5H3.334Z"></path></svg></span></div><span>Remote</span></div><div class="sc-465zle-5 WxTrG"><a aria-live="off" href="/o/project-manager-talent-pool" style="white-space:nowrap" class="sc-s03za1-0 xZUGZ">View job</a></div></div></div></div></output></div></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-image-fb8d4333"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-fb8d4333" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 gZDsxt"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 sc-bq9z91-0 iOQKaL"><div class="sc-1dj1hqi-2 hPupHS"><div class="sc-pelm1o-0 hYJywo"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Our Philosophy</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We have a lot of fun together, something we consider to be really important. The creative process isn’t easy, but enjoying the journey is something we do well. We love what we do, and we think you’ll love working with us.</span></span></span></p></div></div></div></div></div></div><div class="sc-1dj1hqi-2 fXdQP"><div class="sc-11gkm9w-0 lcroFG"><div class="sc-11gkm9w-1 YAzbZ"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img class="sc-146moy0-0 cTyKMn" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/ImA/Z18mPRgadPTx.jpeg" alt="some text" loading="lazy" width="1080" height="1080"/></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-image-c316b05d"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-c316b05d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 kdUgoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 sc-bq9z91-0 OebVS"><div class="sc-1dj1hqi-2 hPupHS"><div class="sc-pelm1o-0 hYJywo"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 cOPlFo"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Our Clients</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">From powerhouses like the Brooklyn Navy Yard, Sesame Workshop, Vital Strategies, and Columbia University, to global movers and shakers like The American Cancer Society, United Nations, the International Rescue Committee, UNICEF, and Women’s Refugee Commission, we’ve worked together to solve some big problems and increase their impact.</span></span></span></p></div></div></div></div></div></div><div class="sc-1dj1hqi-2 fXdQP"><div class="sc-11gkm9w-0 lcroFG"><div class="sc-11gkm9w-1 YAzbZ"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img class="sc-146moy0-0 cTyKMn" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/ImE/pqy0lEe95RqO.jpeg" alt="some text" loading="lazy" width="1080" height="1080"/></div></div></div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-text-f4523764"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-f4523764" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 hacApq"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1we8l0o-0 iZuBTr"><article class="sc-1we8l0o-1 kNKRnF"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="z" data-slate-length="0">﻿</span></span></span><a data-slate-node="element" data-slate-inline="true" href="/" target="_self" data-link="{&quot;target&quot;:&quot;_self&quot;,&quot;type&quot;:&quot;web-address&quot;,&quot;url&quot;:&quot;/&quot;}" class="sc-5egf6r-0 cPMqMQ"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="z" data-slate-length="0">﻿</span></span></span></a><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Join a team of kind, curious, and empathetic individuals</span></span></span></h3><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Radish Lab is a creative agency that believes that good design can help solve big challenges. We partner with organizations that are looking to create greater impact in their work and the world around them.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We believe good design is clear, simple, and engaging. And we believe that good design has the power to move you.We focus on helping social change projects and organizations tell compelling digital stories, deeply engage their audiences, and apply smart creative and technical solutions to some pretty impressive challenges.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">With offices in Brooklyn and Berlin, we love helping our clients create and tell compelling visual stories. </span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Radish Lab is also a certified B Corporation, which means we’re held accountable for meeting the highest standards of overall social and environmental performance, transparency and accountability.</span></span></span></p><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-zero-width="n" data-slate-length="0">﻿<br/></span></span></span></p></div></div></article></div></div></div></div></div></div></section></div><div data-scroll-point="section-gallery-6808b50d"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-6808b50d" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 dLnXab"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 jEioAK"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 ipivQc"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">SELECTED CLIENTS</span></span></span></p><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">We partner with organizations, activists and optimists. Here’s a handful we’ve already helped.</span></span></span></h3></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 ebMZHP"><div width="12" class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-1 iozrWS"><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilg/KFkAhPsAE6m7.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilk/lVkUsYEyvKky.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilo/S5EkxjRNYf4U.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ils/UcXAqrsyzCFC.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div></div></div><div width="12" class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-1 iozrWS"><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Ilw/5vZK251ADpLK.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il0/mJUUpYFqt7ny.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il4/J3g5SeRl41JZ.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div><div width="3" class="sc-1dj1hqi-2 lbZeFW"><span data-cy="image-collection-image" class="sc-fw9s8b-0 bpnyeu"><div class="sc-dkkku4-0 fDyLzp"><div class="sc-dkkku4-1 dHdKMs"><img style="cursor:default" class="sc-146moy0-0 ftWfoy" src="https://careers.recruiteecdn.com/image/upload/q_auto,f_auto,w_1920,c_limit/production/images/Il8/pXhL2Ip7Ng1z.png" alt="" loading="lazy" width="255" height="255"/></div></div></span></div></div></div></div><div></div></div></div></div></div></div></div></div></section></div><div data-scroll-point="section-map-cb09dc8f"><section class="sc-gfrfnr-0 kmsnUh custom-css-section-cb09dc8f" data-cy="section-background-wrapper"><div class="sc-gfrfnr-2 deOrHQ"></div><div class="sc-18h7are-0 ebVyJP"><div class="sc-1tu9fip-2 gJVWbp"><div data-cy="section-wrapper-padder" class="sc-1tu9fip-1 kdUgoN"><div style="color:#000000;font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif;font-weight:400;font-style:normal;text-transform:none" class="sc-1tu9fip-3 iFQjUO"><div class="sc-1dj1hqi-1 bEnYHY"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-1dj1hqi-0 dbJNvX"><div class="sc-1dj1hqi-1 dDTKOA"><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-pelm1o-0 bKUtEV"><div class="sc-pelm1o-2 hmrXLz"><div class="sc-pelm1o-1 ipivQc"><div><div data-gramm="false" data-cy="WYSIWYG-text-edit" class="sc-1tu8yb8-1 cKZGOF" data-slate-editor="true" data-slate-node="value" style="outline:none;white-space:pre-wrap;word-wrap:break-word;font-size:16px;line-height:1.5"><p data-slate-node="element" class="sc-1npqnwg-9 sc-1npqnwg-10 iPueVD slate-p"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">OUR OFFICE</span></span></span></p><h3 data-slate-node="element" class="sc-1npqnwg-4 sc-1npqnwg-5 fXpJdS slate-h3"><span data-slate-node="text"><span data-slate-leaf="true"><span data-slate-string="true">Brooklyn – DUMBO</span></span></span></h3></div></div></div></div></div></div></div></div></div><div class="sc-1dj1hqi-2 dvhjIe"><div class="sc-ji5wy4-0 jIYAZB"><div class="sc-1dj1hqi-1 hohQBp"><div class="sc-1dj1hqi-2 dvhjIe"><div style="width:100%;min-height:400px;position:relative"></div></div></div></div></div></div></div></div></div></div></section></div><div class="sc-ax9y9i-0 jbcdEK"></div></main><div data-cy="brand-wrapper-section" class="sc-1ktojtq-0 beiMHd"><a href="https://recruitee.com" target="_blank" rel="noreferrer noopenner" aria-label="Hiring with Recruitee" class="sc-1ktojtq-1 eovEqQ"><svg width="241" height="24" viewBox="0 0 241 24" fill="none"><path fill-rule="evenodd" clip-rule="evenodd" d="M121.51 9.08403C121.485 9.08403 121.46 9.08469 121.435 9.08493C119.658 3.80365 114.669 0 108.792 0C102.914 0 97.9245 3.80438 96.1478 9.08648C91.9409 9.19007 88.5625 12.6349 88.5625 16.8693C88.5625 19.0446 89.4544 21.0112 90.8919 22.4237C91.0503 22.5794 91.3 22.5947 91.475 22.4578C91.6655 22.309 91.8748 22.1555 92.1031 22.0014C92.8412 21.4518 93.8535 20.9681 94.7804 20.6317C94.9048 20.5882 95.4997 20.264 95.1679 19.3905C94.3151 18.5164 93.6697 17.1028 93.6697 15.7125C93.6697 13.5824 95.0765 12.4652 96.7245 12.4652C98.3699 12.4652 99.7851 13.5824 99.7851 15.7125C99.7851 17.0983 99.1371 18.5061 98.2862 19.3801H98.2914C97.9674 20.3704 98.4891 20.6063 98.5701 20.6317C98.857 20.727 99.1495 20.8358 99.4388 20.9557C99.5856 21.0166 99.6222 21.2094 99.5079 21.3197C98.7283 22.0729 98.2735 23.0327 98.0347 23.7028C97.9565 23.9223 98.227 24.0979 98.3967 23.9383C98.9716 23.3983 99.7391 22.7543 100.705 22.1024C101.974 21.1571 103.715 20.3252 105.31 19.7465C105.524 19.6718 106.547 19.1141 105.976 17.6118C104.509 16.1084 103.399 13.6771 103.399 11.2858C103.399 7.62214 105.819 5.70046 108.653 5.70046C111.483 5.70046 113.918 7.62214 113.918 11.2858C113.918 13.6692 112.803 16.0906 111.34 17.5939H111.348C110.791 19.297 111.688 19.703 111.828 19.7465C113.453 20.2863 115.183 21.0737 116.465 21.986C117.538 22.6469 118.404 23.3224 119.071 23.9113C119.243 24.0636 119.504 23.8864 119.427 23.6697C119.19 23.0021 118.723 22.0192 117.921 21.2592C117.805 21.1494 117.841 20.9569 117.988 20.8938C118.234 20.7878 118.481 20.6904 118.722 20.6028C118.847 20.5592 119.444 20.2339 119.111 19.3576C118.255 18.4806 117.608 17.0623 117.608 15.6675C117.608 13.5303 119.019 12.4092 120.672 12.4092C122.323 12.4092 123.743 13.5303 123.743 15.6675C123.743 17.0577 123.093 18.4701 122.239 19.3471H122.245C121.92 20.3406 122.443 20.5774 122.524 20.6028C123.884 21.0545 125.37 21.8032 126.029 22.6379C126.187 22.8377 126.481 22.8633 126.671 22.6944C128.277 21.2682 129.29 19.1872 129.29 16.8693C129.29 12.5696 125.807 9.08403 121.51 9.08403Z" fill="#1999E3"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M144.982 8.29481C144.982 9.17907 144.835 9.97335 144.532 10.653C143.959 10.5875 143.321 10.5383 142.928 10.5383C142.331 10.5383 141.504 10.653 140.973 10.8987C140.351 11.1853 139.941 11.7339 139.941 12.8803V21.1096C139.18 21.4782 138.297 21.6255 137.29 21.6255V11.693C137.29 10.1126 137.904 9.29375 139.303 8.72875C140.4 8.28657 141.799 8.0573 142.896 8.0573C143.55 8.0573 144.336 8.13913 144.982 8.29481Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M154.786 13.7155C155.654 13.7155 155.891 13.3388 155.891 12.7738C155.891 11.2917 154.287 10.3746 152.519 10.3746C150.49 10.3746 148.894 11.5784 148.501 13.7155H154.786ZM152.912 21.6255C148.493 21.6255 145.793 18.8742 145.793 14.8456C145.793 10.8414 148.452 8.05731 152.536 8.05731C155.997 8.05731 158.477 10.0553 158.477 13.3142C158.477 15.2386 157.609 15.8117 155.572 15.8117H148.485C148.87 17.9981 150.547 19.2099 153.019 19.2099C154.238 19.2099 155.523 18.9152 156.415 18.6204C156.734 19.2837 156.865 20.0616 156.865 20.9295C155.76 21.3225 154.377 21.6255 152.912 21.6255Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M160.187 14.8456C160.187 10.8496 162.904 8.05731 167.306 8.05731C168.755 8.05731 170.121 8.36027 171.169 8.72876C171.169 9.59672 171.038 10.3582 170.727 11.0133C169.876 10.7186 168.583 10.4565 167.478 10.4565C164.622 10.4565 162.846 12.1924 162.846 14.8456C162.846 17.4985 164.63 19.1772 167.429 19.1772C168.624 19.1772 169.917 18.8742 170.809 18.5713C171.112 19.2509 171.259 20.0452 171.259 20.9295C170.154 21.3225 168.771 21.6255 167.315 21.6255C162.904 21.6255 160.187 18.8415 160.187 14.8456Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M181.578 8.29482C181.578 9.17908 181.431 9.97336 181.128 10.653C180.555 10.5875 179.917 10.5384 179.524 10.5384C178.927 10.5384 178.1 10.653 177.568 10.8987C176.947 11.1853 176.537 11.7339 176.537 12.8803V21.1096C175.776 21.4782 174.892 21.6255 173.885 21.6255V11.693C173.885 10.1126 174.5 9.29376 175.899 8.72876C176.995 8.28659 178.395 8.05731 179.491 8.05731C180.146 8.05731 180.931 8.13914 181.578 8.29482Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M186.112 15.5825C186.112 17.6377 187.225 19.1854 189.336 19.1854C189.68 19.1854 190.539 19.1444 191.243 18.8579C191.987 18.5548 192.249 18.0799 192.249 17.3675V8.57317C193.01 8.20468 193.894 8.05731 194.9 8.05731V17.9899C194.9 19.5702 194.262 20.4137 192.887 20.9541C191.807 21.3799 190.236 21.6255 189.099 21.6255C185.629 21.6255 183.461 19.341 183.461 15.7954V8.57317C184.221 8.20468 185.105 8.05731 186.112 8.05731V15.5825Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M201.104 21.1096C200.342 21.4782 199.458 21.6255 198.452 21.6255V8.57314C199.213 8.20465 200.097 8.05729 201.104 8.05729V21.1096ZM201.529 4.11866C201.529 5.08492 200.752 5.86282 199.786 5.86282C198.821 5.86282 198.043 5.08492 198.043 4.11866C198.043 3.15241 198.821 2.37451 199.786 2.37451C200.752 2.37451 201.529 3.15241 201.529 4.11866Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M208.288 10.7267V17.0073C208.288 18.866 209.532 19.1772 211.815 19.1772C211.815 20.0697 211.684 20.8558 211.357 21.5273C211.005 21.6009 210.768 21.6255 210.391 21.6255C209.008 21.6255 206.913 21.298 206.063 19.4392C205.677 18.604 205.637 17.6459 205.637 16.6142V10.7267H203.288C203.288 9.80145 203.419 8.99894 203.754 8.30296H205.637V4.60176C206.397 4.23327 207.281 4.08591 208.288 4.08591V8.30296H211.897C211.897 9.22007 211.758 10.0306 211.422 10.7267H208.288Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M222.347 13.7155C223.215 13.7155 223.453 13.3388 223.453 12.7738C223.453 11.2917 221.849 10.3746 220.081 10.3746C218.051 10.3746 216.456 11.5784 216.063 13.7155H222.347ZM220.474 21.6255C216.055 21.6255 213.355 18.8742 213.355 14.8456C213.355 10.8414 216.014 8.05731 220.097 8.05731C223.558 8.05731 226.038 10.0553 226.038 13.3142C226.038 15.2386 225.17 15.8117 223.133 15.8117H216.047C216.431 17.9981 218.108 19.2099 220.58 19.2099C221.799 19.2099 223.084 18.9152 223.976 18.6204C224.295 19.2837 224.426 20.0616 224.426 20.9295C223.321 21.3225 221.938 21.6255 220.474 21.6255Z" fill="#37474F"></path><path fill-rule="evenodd" clip-rule="evenodd" d="M236.75 13.7155C237.618 13.7155 237.855 13.3388 237.855 12.7738C237.855 11.2917 236.251 10.3746 234.483 10.3746C232.454 10.3746 230.858 11.5784 230.465 13.7155H236.75ZM234.876 21.6255C230.457 21.6255 227.757 18.8742 227.757 14.8456C227.757 10.8414 230.416 8.05731 234.499 8.05731C237.961 8.05731 240.441 10.0553 240.441 13.3142C240.441 15.2386 239.573 15.8117 237.535 15.8117H230.449C230.833 17.9981 232.511 19.2099 234.982 19.2099C236.202 19.2099 237.486 18.9152 238.378 18.6204C238.698 19.2837 238.829 20.0616 238.829 20.9295C237.723 21.3225 236.341 21.6255 234.876 21.6255Z" fill="#37474F"></path><path d="M9 20V8.72656H7.59375V13.6016H1.40625V8.72656H0V20H1.40625V14.8672H7.59375V20H9Z" fill="#37474F"></path><path d="M12.4062 9.95312C12.9219 9.95312 13.3438 9.53125 13.3438 9.01562C13.3438 8.5 12.9219 8.07812 12.4062 8.07812C11.8906 8.07812 11.4688 8.5 11.4688 9.01562C11.4688 9.53125 11.8906 9.95312 12.4062 9.95312ZM11.7344 20H13.0781V11.5781H11.7344V20Z" fill="#37474F"></path><path d="M15.6406 20H16.9844V14.7812C16.9844 13.5938 17.9141 12.7344 19.1953 12.7344C19.4609 12.7344 19.9453 12.7812 20.0547 12.8125V11.4688C19.8828 11.4453 19.6016 11.4297 19.3828 11.4297C18.2656 11.4297 17.2969 12.0078 17.0469 12.8281H16.9219V11.5781H15.6406V20Z" fill="#37474F"></path><path d="M22.4375 9.95312C22.9531 9.95312 23.375 9.53125 23.375 9.01562C23.375 8.5 22.9531 8.07812 22.4375 8.07812C21.9219 8.07812 21.5 8.5 21.5 9.01562C21.5 9.53125 21.9219 9.95312 22.4375 9.95312ZM21.7656 20H23.1094V11.5781H21.7656V20Z" fill="#37474F"></path><path d="M25.6719 20H27.0156V15.0156C27.0156 13.5391 27.8828 12.6406 29.2266 12.6406C30.5703 12.6406 31.2109 13.3594 31.2109 14.875V20H32.5547V14.5469C32.5547 12.5469 31.5 11.4297 29.6094 11.4297C28.3203 11.4297 27.5 11.9766 27.0781 12.9062H26.9531V11.5781H25.6719V20Z" fill="#37474F"></path><path d="M38.4844 23.2344C40.7812 23.2344 42.2344 22.0312 42.2344 20.1484V11.5781H40.9531V12.9141H40.8281C40.3438 12.0078 39.3047 11.4297 38.125 11.4297C35.9609 11.4297 34.5938 13.1406 34.5938 15.6641C34.5938 18.1875 35.9453 19.875 38.125 19.875C39.2812 19.875 40.2344 19.3516 40.7656 18.4219H40.8906V20.0781C40.8906 21.3203 39.9922 22.0625 38.4844 22.0625C37.2734 22.0625 36.5234 21.6172 36.375 20.9297H34.9531C35.1562 22.3203 36.4531 23.2344 38.4844 23.2344ZM38.4219 18.6875C36.8594 18.6875 35.9844 17.5 35.9844 15.6641C35.9844 13.8281 36.8594 12.6406 38.4219 12.6406C39.9766 12.6406 40.9219 13.8281 40.9219 15.6641C40.9219 17.5 39.9844 18.6875 38.4219 18.6875Z" fill="#37474F"></path><path d="M59.875 11.5781H58.5234L56.8672 18.3125H56.7422L54.8594 11.5781H53.5703L51.6875 18.3125H51.5625L49.9062 11.5781H48.5469L50.9062 20H52.2656L54.1406 13.4844H54.2656L56.1484 20H57.5156L59.875 11.5781Z" fill="#37474F"></path><path d="M62.375 9.95312C62.8906 9.95312 63.3125 9.53125 63.3125 9.01562C63.3125 8.5 62.8906 8.07812 62.375 8.07812C61.8594 8.07812 61.4375 8.5 61.4375 9.01562C61.4375 9.53125 61.8594 9.95312 62.375 9.95312ZM61.7031 20H63.0469V11.5781H61.7031V20Z" fill="#37474F"></path><path d="M66.1719 9.39844V11.5781H64.8125V12.7031H66.1719V17.8125C66.1719 19.4219 66.8672 20.0625 68.6016 20.0625C68.8672 20.0625 69.125 20.0312 69.3906 19.9844V18.8516C69.1406 18.875 69.0078 18.8828 68.7656 18.8828C67.8906 18.8828 67.5156 18.4609 67.5156 17.4688V12.7031H69.3906V11.5781H67.5156V9.39844H66.1719Z" fill="#37474F"></path><path d="M71.5 20H72.8438V15.0156C72.8438 13.5938 73.6719 12.6406 75.1797 12.6406C76.4531 12.6406 77.125 13.3828 77.125 14.875V20H78.4688V14.5469C78.4688 12.5703 77.3438 11.4297 75.5625 11.4297C74.2734 11.4297 73.3906 11.9766 72.9688 12.9062H72.8438V8.23438H71.5V20Z" fill="#37474F"></path></svg></a></div></div></div>


<script id="__LOADABLE_REQUIRED_CHUNKS__" type="application/json">[]</script><script id="__LOADABLE_REQUIRED_CHUNKS___ext" type="application/json">{"namedChunks":[]}</script>
<script async data-chunk="main" src="/js/PublicApp/web/main-bundle-ed69588b.js"></script>


  </body>
</html>

-  recorded_at: Mon, 29 Jul 2024 09:07:03 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:53 GMT
 - request:
     method: get
     uri: https://radishlab.recruitee.com/api/offers/
@@ -121,7 +121,7 @@ http_interactions:
       Content-Type:
       - application/json; charset=utf-8
       Date:
-      - Mon, 29 Jul 2024 09:07:03 GMT
+      - Tue, 30 Jul 2024 16:28:52 GMT
       Server:
       - Cowboy
       Strict-Transport-Security:
@@ -129,7 +129,7 @@ http_interactions:
       Vary:
       - accept-encoding
       X-Request-Id:
-      - F-aj0HaBJpKHzSwI7k2j
+      - F-cKgXrIU-FtJTMAm4wD
       Via:
       - 1.1 google
       Alt-Svc:
@@ -139,11 +139,11 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"offers":[{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1390320,"sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-07-25 17:53:46 UTC","position":45,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"56ucy","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","created_at":"2023-07-25 16:04:54 UTC","options_cv":"required","updated_at":"2024-07-10 09:55:41 UTC","department":null,"translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_image":null,"sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool","options_phone":"required","slug":"copywriter-talen-pool","employment_type_code":"contract","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Copywriter Talent Pool","postal_code":null,"status":"published","state_code":"NY","open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"salary":{"max":null,"min":null,"period":null,"currency":null},"country_code":"US","options_photo":"optional","title":"Copywriter Talent Pool","options_cover_letter":"optional","locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"city":"BROOKLYN","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","min_hours":null,"education_code":"bachelor_degree","mailbox_email":"job.56ucy@radishlab.recruitee.com","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","category_code":"design"},{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1357326,"sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-06-21 22:14:02 UTC","position":43,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"u4kva","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","created_at":"2023-06-21 22:11:24 UTC","options_cv":"required","updated_at":"2024-06-10 18:24:23 UTC","department":"Strategy & Project Management","translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_image":null,"sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool","options_phone":"optional","slug":"project-manager-talent-pool","employment_type_code":"fulltime","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Project Manager Talent Pool","postal_code":"11201","status":"published","state_code":"NY","open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"country_code":"US","options_photo":"off","title":"Project Manager Talent Pool","options_cover_letter":"optional","locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","postal_code":"11201","street":"20 Jay Street","note":null}},"country_code":"US","postal_code":"11201","state_code":"NY","street":"20 Jay Street","note":null}],"city":"Brooklyn","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","min_hours":null,"education_code":"professional","mailbox_email":"job.u4kva@radishlab.recruitee.com","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","category_code":"design"},{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1333509,"sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-07-24 19:56:03 UTC","position":42,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"pwpku","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","created_at":"2023-05-31 13:38:00 UTC","options_cv":"required","updated_at":"2024-06-30 19:58:06 UTC","department":"Development","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_image":null,"sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool","options_phone":"required","slug":"developer-talent-pool","employment_type_code":"contract","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Developer Talent Pool","postal_code":null,"status":"published","state_code":"NY","open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"salary":{"max":null,"min":null,"period":null,"currency":null},"country_code":"US","options_photo":"optional","title":"Developer Talent Pool","options_cover_letter":"optional","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"city":"New York","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","min_hours":null,"education_code":"bachelor_degree","mailbox_email":"job.pwpku@radishlab.recruitee.com","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","category_code":"technical"},{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1333465,"sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-07-24 19:56:30 UTC","position":41,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"2ccy3","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","created_at":"2023-05-31 13:19:38 UTC","options_cv":"required","updated_at":"2024-07-10 01:26:39 UTC","department":"Design","translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_image":null,"sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/design-talent-pool","options_phone":"required","slug":"design-talent-pool","employment_type_code":"contract","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Design Talent Pool","postal_code":null,"status":"published","state_code":"NY","open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"salary":{"max":null,"min":null,"period":null,"currency":null},"country_code":"US","options_photo":"optional","title":"Design Talent Pool","options_cover_letter":"optional","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"city":"New York","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","min_hours":null,"education_code":"bachelor_degree","mailbox_email":"job.2ccy3@radishlab.recruitee.com","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","category_code":"design"}]}
-  recorded_at: Mon, 29 Jul 2024 09:07:03 GMT
+        {"offers":[{"published_at":"2023-07-25 17:53:46 UTC","slug":"copywriter-talen-pool","on_site":false,"location_question_visible":false,"id":1390320,"location":"Remote job","remote":true,"category_code":"design","position":45,"max_hours_per_week":"40.0","mailbox_email":"job.56ucy@radishlab.recruitee.com","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_image":null,"sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"postal_code":null,"locations_question_required":true,"options_photo":"optional","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","country":"United States","options_cv":"required","min_hours_per_week":"30.0","sharing_title":"Copywriter Talent Pool","employment_type_code":"contract","state_code":"NY","careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","education_code":"bachelor_degree","experience_code":"mid_level","salary":{"max":null,"min":null,"period":null,"currency":null},"cover_image":null,"tags":[],"guid":"56ucy","options_phone":"required","open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"state_name":"New York","status":"published","close_at":null,"created_at":"2023-07-25 16:04:54 UTC","title":"Copywriter Talent Pool","hybrid":false,"locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"locations_question_type":"multiple_choice","sharing_image":null,"city":"BROOKLYN","max_hours":null,"country_code":"US","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","department":null,"updated_at":"2024-07-10 09:55:41 UTC","min_hours":null,"company_name":"Radish Lab","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","options_cover_letter":"optional","careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool"},{"published_at":"2023-06-21 22:14:02 UTC","slug":"project-manager-talent-pool","on_site":false,"location_question_visible":false,"id":1357326,"location":"Remote job","remote":true,"category_code":"design","position":43,"max_hours_per_week":"40.0","mailbox_email":"job.u4kva@radishlab.recruitee.com","translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_image":null,"sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"postal_code":"11201","locations_question_required":true,"options_photo":"off","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","country":"United States","options_cv":"required","min_hours_per_week":"30.0","sharing_title":"Project Manager Talent Pool","employment_type_code":"fulltime","state_code":"NY","careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","education_code":"professional","experience_code":"mid_level","salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"cover_image":null,"tags":[],"guid":"u4kva","options_phone":"optional","open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"state_name":"New York","status":"published","close_at":null,"created_at":"2023-06-21 22:11:24 UTC","title":"Project Manager Talent Pool","hybrid":false,"locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","postal_code":"11201","street":"20 Jay Street","note":null}},"country_code":"US","postal_code":"11201","state_code":"NY","street":"20 Jay Street","note":null}],"locations_question_type":"multiple_choice","sharing_image":null,"city":"Brooklyn","max_hours":null,"country_code":"US","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","department":"Strategy & Project Management","updated_at":"2024-06-10 18:24:23 UTC","min_hours":null,"company_name":"Radish Lab","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","options_cover_letter":"optional","careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool"},{"published_at":"2023-07-24 19:56:03 UTC","slug":"developer-talent-pool","on_site":false,"location_question_visible":false,"id":1333509,"location":"Remote job","remote":true,"category_code":"technical","position":42,"max_hours_per_week":"40.0","mailbox_email":"job.pwpku@radishlab.recruitee.com","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_image":null,"sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"postal_code":null,"locations_question_required":true,"options_photo":"optional","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","country":"United States","options_cv":"required","min_hours_per_week":"30.0","sharing_title":"Developer Talent Pool","employment_type_code":"contract","state_code":"NY","careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","education_code":"bachelor_degree","experience_code":"mid_level","salary":{"max":null,"min":null,"period":null,"currency":null},"cover_image":null,"tags":[],"guid":"pwpku","options_phone":"required","open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"state_name":"New York","status":"published","close_at":null,"created_at":"2023-05-31 13:38:00 UTC","title":"Developer Talent Pool","hybrid":false,"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"locations_question_type":"multiple_choice","sharing_image":null,"city":"New York","max_hours":null,"country_code":"US","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","department":"Development","updated_at":"2024-06-30 19:58:06 UTC","min_hours":null,"company_name":"Radish Lab","locations_question":"What is your preferred work location?","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","options_cover_letter":"optional","careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool"},{"published_at":"2023-07-24 19:56:30 UTC","slug":"design-talent-pool","on_site":false,"location_question_visible":false,"id":1333465,"location":"Remote job","remote":true,"category_code":"design","position":41,"max_hours_per_week":"40.0","mailbox_email":"job.2ccy3@radishlab.recruitee.com","translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_image":null,"sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"postal_code":null,"locations_question_required":true,"options_photo":"optional","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","country":"United States","options_cv":"required","min_hours_per_week":"30.0","sharing_title":"Design Talent Pool","employment_type_code":"contract","state_code":"NY","careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","education_code":"bachelor_degree","experience_code":"mid_level","salary":{"max":null,"min":null,"period":null,"currency":null},"cover_image":null,"tags":[],"guid":"2ccy3","options_phone":"required","open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"state_name":"New York","status":"published","close_at":null,"created_at":"2023-05-31 13:19:38 UTC","title":"Design Talent Pool","hybrid":false,"locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"locations_question_type":"multiple_choice","sharing_image":null,"city":"New York","max_hours":null,"country_code":"US","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","department":"Design","updated_at":"2024-07-10 01:26:39 UTC","min_hours":null,"company_name":"Radish Lab","locations_question":"What is your preferred work location?","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","options_cover_letter":"optional","careers_url":"https://radishlab.recruitee.com/o/design-talent-pool"}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:53 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.radishlab.com/"]}],"limit":1}'
@@ -166,9 +166,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:07:03 GMT
+      - Tue, 30 Jul 2024 16:28:54 GMT
       Etag:
-      - W/"1722244023918"
+      - W/"1722356934353"
       Server:
       - openresty
       X-Cb-Engine:
@@ -180,7 +180,7 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '4'
+      - '5'
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
@@ -195,8 +195,8 @@ http_interactions:
         Lab","identifier":{"permalink":"radish-lab","image_id":"twahkcz5ajw2iyujvuqc","uuid":"f9940cee-5c3e-4ce2-c124-9b4fc6fb72c6","entity_def_id":"organization","value":"Radish
         Lab"},"linkedin":{"value":"https://www.linkedin.com/company/radish-media-llc"},"short_description":"Radish
         Lab is a full-service interactive creative agency focused on people and projects
-        changing the world.","rank_org":1019659,"website_url":"http://radishlab.com/"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:07:03 GMT
+        changing the world.","rank_org":1013571,"website_url":"http://radishlab.com/"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:28:54 GMT
 - request:
     method: get
     uri: https://radishlab.recruitee.com/api/offers/
@@ -220,7 +220,7 @@ http_interactions:
       Content-Type:
       - application/json; charset=utf-8
       Date:
-      - Mon, 29 Jul 2024 09:07:04 GMT
+      - Tue, 30 Jul 2024 16:28:53 GMT
       Server:
       - Cowboy
       Strict-Transport-Security:
@@ -228,7 +228,7 @@ http_interactions:
       Vary:
       - accept-encoding
       X-Request-Id:
-      - F-aj0KbBp3v40mMSB4wC
+      - F-cKgagUD9YlLZYAot6j
       Via:
       - 1.1 google
       Alt-Svc:
@@ -238,8 +238,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"offers":[{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1390320,"sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-07-25 17:53:46 UTC","position":45,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"56ucy","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","created_at":"2023-07-25 16:04:54 UTC","options_cv":"required","updated_at":"2024-07-10 09:55:41 UTC","department":null,"translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_image":null,"sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool","options_phone":"required","slug":"copywriter-talen-pool","employment_type_code":"contract","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Copywriter Talent Pool","postal_code":null,"status":"published","state_code":"NY","open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"salary":{"max":null,"min":null,"period":null,"currency":null},"country_code":"US","options_photo":"optional","title":"Copywriter Talent Pool","options_cover_letter":"optional","locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"city":"BROOKLYN","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","min_hours":null,"education_code":"bachelor_degree","mailbox_email":"job.56ucy@radishlab.recruitee.com","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","category_code":"design"},{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1357326,"sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-06-21 22:14:02 UTC","position":43,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"u4kva","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","created_at":"2023-06-21 22:11:24 UTC","options_cv":"required","updated_at":"2024-06-10 18:24:23 UTC","department":"Strategy & Project Management","translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_image":null,"sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool","options_phone":"optional","slug":"project-manager-talent-pool","employment_type_code":"fulltime","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Project Manager Talent Pool","postal_code":"11201","status":"published","state_code":"NY","open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"country_code":"US","options_photo":"off","title":"Project Manager Talent Pool","options_cover_letter":"optional","locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","postal_code":"11201","street":"20 Jay Street","note":null}},"country_code":"US","postal_code":"11201","state_code":"NY","street":"20 Jay Street","note":null}],"city":"Brooklyn","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","min_hours":null,"education_code":"professional","mailbox_email":"job.u4kva@radishlab.recruitee.com","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","category_code":"design"},{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1333509,"sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-07-24 19:56:03 UTC","position":42,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"pwpku","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","created_at":"2023-05-31 13:38:00 UTC","options_cv":"required","updated_at":"2024-06-30 19:58:06 UTC","department":"Development","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_image":null,"sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool","options_phone":"required","slug":"developer-talent-pool","employment_type_code":"contract","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Developer Talent Pool","postal_code":null,"status":"published","state_code":"NY","open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"salary":{"max":null,"min":null,"period":null,"currency":null},"country_code":"US","options_photo":"optional","title":"Developer Talent Pool","options_cover_letter":"optional","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"city":"New York","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","min_hours":null,"education_code":"bachelor_degree","mailbox_email":"job.pwpku@radishlab.recruitee.com","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","category_code":"technical"},{"min_hours_per_week":"30.0","hybrid":false,"state_name":"New York","id":1333465,"sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","remote":true,"close_at":null,"sharing_image":null,"company_name":"Radish Lab","published_at":"2023-07-24 19:56:30 UTC","position":41,"location":"Remote job","max_hours_per_week":"40.0","cover_image":null,"max_hours":null,"country":"United States","locations_question_required":true,"guid":"2ccy3","experience_code":"mid_level","careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","created_at":"2023-05-31 13:19:38 UTC","options_cv":"required","updated_at":"2024-07-10 01:26:39 UTC","department":"Design","translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_image":null,"sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"careers_url":"https://radishlab.recruitee.com/o/design-talent-pool","options_phone":"required","slug":"design-talent-pool","employment_type_code":"contract","location_question_visible":false,"on_site":false,"locations_question":"What is your preferred work location?","tags":[],"locations_question_type":"multiple_choice","sharing_title":"Design Talent Pool","postal_code":null,"status":"published","state_code":"NY","open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"salary":{"max":null,"min":null,"period":null,"currency":null},"country_code":"US","options_photo":"optional","title":"Design Talent Pool","options_cover_letter":"optional","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","postal_code":null,"street":null,"note":null}},"country_code":"US","postal_code":null,"state_code":"NY","street":null,"note":null}],"city":"New York","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","min_hours":null,"education_code":"bachelor_degree","mailbox_email":"job.2ccy3@radishlab.recruitee.com","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","category_code":"design"}]}
-  recorded_at: Mon, 29 Jul 2024 09:07:04 GMT
+        {"offers":[{"cover_image":null,"company_name":"Radish Lab","id":1390320,"sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","options_photo":"optional","remote":true,"state_code":"NY","hybrid":false,"position":45,"location":"Remote job","close_at":null,"published_at":"2023-07-25 17:53:46 UTC","max_hours_per_week":"40.0","locations_question_type":"multiple_choice","on_site":false,"country":"United States","requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","mailbox_email":"job.56ucy@radishlab.recruitee.com","options_cv":"required","locations":[{"id":94693,"name":"BROOKLYN","state":"New York","country":"United States","city":"BROOKLYN","translations":{"en":{"name":"BROOKLYN","city":"BROOKLYN","note":null,"postal_code":null,"street":null}},"country_code":"US","state_code":"NY","note":null,"postal_code":null,"street":null}],"careers_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool","employment_type_code":"contract","experience_code":"mid_level","salary":{"max":null,"min":null,"period":null,"currency":null},"location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/copywriter-talen-pool/c/new","category_code":"design","tags":[],"max_hours":null,"title":"Copywriter Talent Pool","country_code":"US","city":"BROOKLYN","state_name":"New York","sharing_title":"Copywriter Talent Pool","status":"published","min_hours":null,"guid":"56ucy","department":null,"open_questions":[{"id":2039662,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":2039663,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2039664,"position":3,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of Eastern Standard Time?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of Eastern Standard Time?"}},"open_question_options":[]},{"id":2039665,"position":4,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039668,"position":5,"options":{"length":120},"required":false,"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":2039673,"position":6,"options":{"length":120},"required":true,"body":"What Country are you located in?","kind":"string","translations":{"en":{"body":"What Country are you located in?"}},"open_question_options":[]},{"id":2039672,"position":7,"options":{"length":120},"required":true,"body":"What State/Region are you located in?","kind":"string","translations":{"en":{"body":"What State/Region are you located in?"}},"open_question_options":[]},{"id":2039671,"position":8,"options":{"length":120},"required":true,"body":"What City are you located in?","kind":"string","translations":{"en":{"body":"What City are you located in?"}},"open_question_options":[]},{"id":2039669,"position":9,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":2039670,"position":10,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If so, please list).","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If so, please list)."}},"open_question_options":[]},{"id":2039666,"position":11,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"string","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":2039667,"position":12,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"string","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"options_cover_letter":"optional","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","title":"Copywriter Talent Pool","sharing_image":null,"requirements":"<ul><li dir=\"ltr\"><p dir=\"ltr\">Proven experience as a copywriter with a portfolio of relevant work samples</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience writing SEO-friendly copy for the web is a must</p></li><li dir=\"ltr\"><p dir=\"ltr\">Strong writing, editing, and proofreading skills with an attention to detail</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ability to work efficiently and meet deadlines in a fast-paced environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Nice to have experience writing for social impact organizations, philanthropy, and fundraising</p></li></ul>\n<p dir=\"ltr\">If you're a talented Copywriter with a passion for storytelling and creating meaningful content, we want to hear from you! Please submit your resume, portfolio, and any relevant writing samples to be considered for the role and share your hourly rate.</p>","sharing_title":"Copywriter Talent Pool","sharing_description":"Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. \n\nThe ideal candidate w","locations_question":"What is your preferred work location?"}},"postal_code":null,"sharing_image":null,"updated_at":"2024-07-10 09:55:41 UTC","created_at":"2023-07-25 16:04:54 UTC","education_code":"bachelor_degree","options_phone":"required","slug":"copywriter-talen-pool","locations_question":"What is your preferred work location?","min_hours_per_week":"30.0","description":"<p dir=\"ltr\">Radish Lab, a creative agency based in Brooklyn, NY, is always accepting applications for Freelance Copywriters to join our team for various projects for our nonprofit clients. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate will have experience writing copy specifically for the web and can produce high-quality work within tight deadlines. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\"><strong>Responsibilities:</strong><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Ensure all content is on-brand, consistent in tone, and optimized for SEO</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work closely with our team to ensure that all content is aligned with the client’s brand and voice</p></li><li dir=\"ltr\"><p dir=\"ltr\">Meet all deadlines and deliverables</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incorporate client feedback and make revisions through 2 rounds of revisions</p></li></ul>","locations_question_required":true},{"cover_image":null,"company_name":"Radish Lab","id":1357326,"sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","options_photo":"off","remote":true,"state_code":"NY","hybrid":false,"position":43,"location":"Remote job","close_at":null,"published_at":"2023-06-21 22:14:02 UTC","max_hours_per_week":"40.0","locations_question_type":"multiple_choice","on_site":false,"country":"United States","requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","mailbox_email":"job.u4kva@radishlab.recruitee.com","options_cv":"required","locations":[{"id":94690,"name":"Brooklyn, 11201 (2)","state":"New York","country":"United States","city":"Brooklyn","translations":{"en":{"name":"Brooklyn, 11201 (2)","city":"Brooklyn","note":null,"postal_code":"11201","street":"20 Jay Street"}},"country_code":"US","state_code":"NY","note":null,"postal_code":"11201","street":"20 Jay Street"}],"careers_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool","employment_type_code":"fulltime","experience_code":"mid_level","salary":{"max":"68000","min":"52000","period":"year","currency":"USD"},"location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/project-manager-talent-pool/c/new","category_code":"design","tags":[],"max_hours":null,"title":"Project Manager Talent Pool","country_code":"US","city":"Brooklyn","state_name":"New York","sharing_title":"Project Manager Talent Pool","status":"published","min_hours":null,"guid":"u4kva","department":"Strategy & Project Management","open_questions":[{"id":1979951,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment?"}},"open_question_options":[]},{"id":1979966,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"string","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":1979947,"position":3,"options":{"length":120},"required":true,"body":"Are you based in the United States?","kind":"boolean","translations":{"en":{"body":"Are you based in the United States?"}},"open_question_options":[]},{"id":1979983,"position":4,"options":{"length":120},"required":false,"body":"What City and State do you currently live in?","kind":"string","translations":{"en":{"body":"What City and State do you currently live in?"}},"open_question_options":[]},{"id":1979952,"position":5,"options":{"length":120},"required":true,"body":"Are you located within 3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Are you located within 3 hours of EST?"}},"open_question_options":[]},{"id":1979986,"position":6,"options":{"length":120},"required":true,"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are inside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979948,"position":7,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1979953,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this opening?","kind":"text","translations":{"en":{"body":"Where did you find out about this opening?"}},"open_question_options":[]},{"id":1979949,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time).","kind":"boolean","translations":{"en":{"body":"If you are outside of the US, do you require work sponsorship now or in the future? (we are not sponsoring visas at this time)."}},"open_question_options":[]},{"id":1979984,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1979985,"position":11,"options":{"length":120},"required":false,"body":"Do you speak any other languages? (If yes, please list)","kind":"string","translations":{"en":{"body":"Do you speak any other languages? (If yes, please list)"}},"open_question_options":[]},{"id":1979950,"position":12,"options":{"length":120},"required":true,"body":"Do you have experience being a project manager on web design and development projects? ","kind":"boolean","translations":{"en":{"body":"Do you have experience being a project manager on web design and development projects? "}},"open_question_options":[]}],"options_cover_letter":"optional","translations":{"en":{"description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","title":"Project Manager Talent Pool","sharing_image":null,"requirements":"<p dir=\"ltr\"><strong>Job Requirements</strong></p>\n<p><br /></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">At least one year of client-facing digital/design/creative agency experience in a project or account management role (preferably 2-3 years)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with web development process and concepts and project management methodologies (Familiarity with Wordpress is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Familiarity with basic design process, as well as working knowledge of design tools and creative production (Familiarity with tools like Figma is preferred)</p></li><li dir=\"ltr\"><p dir=\"ltr\">A commitment to progressive social change movements, and a desire to work on mission-driven projects</p></li><li dir=\"ltr\"><p dir=\"ltr\">A desire to work with a small, talented team of nice people committed to making their jobs as fun and meaningful as possible</p></li><li dir=\"ltr\"><p dir=\"ltr\">We use a waterfall approach. Scrum certification or experience with agile web development is not required but could be helpful.</p></li></ul>\n<p dir=\"ltr\"><strong>Location</strong></p>\n<p dir=\"ltr\">This position is remote. US only. We prefer candidates in the EST timezone. </p>","sharing_title":"Project Manager Talent Pool","sharing_description":"We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.\n\nRadish Lab is a ","locations_question":"What is your preferred work location?"}},"postal_code":"11201","sharing_image":null,"updated_at":"2024-06-10 18:24:23 UTC","created_at":"2023-06-21 22:11:24 UTC","education_code":"professional","options_phone":"optional","slug":"project-manager-talent-pool","locations_question":"What is your preferred work location?","min_hours_per_week":"30.0","description":"<p dir=\"ltr\"><strong>We are not currently hiring for a Project Manager but always happy to accept resumes and add to our Talent Pool. This is the job description for the last time we hired this position.</strong></p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is a social-impact-focused digital agency, shaping stories and sharpening brands for organizations improving the world. </p>\n<p dir=\"ltr\"><strong><br /></strong></p>\n<p dir=\"ltr\"><strong>In your most recent role you have:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Led website design and development projects of all sizes simultaneously from start to finish, coordinating between the client and a team of strategists, designers, and developers</p></li><li dir=\"ltr\"><p dir=\"ltr\">Anticipated potential roadblocks and addressed and shared learnings throughout the project process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Been sought out as a resource and creative problem-solver by teammates</p></li></ul>\n<p dir=\"ltr\">You'll manage the relationship between the client and the Radish project team. You are equally energized by checking tasks off of a well-organized to-do list as you are closely managing the team’s capacity, monitoring project budgets, and building strong relationships with teammates and client points of contact. You are key in coordinating the work of the project team as they translate ideas into strategic, creative, and/or digital products for organizations working in the social-impact space.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">The ideal candidate has at least one year of experience (2-3 preferred) being a Project Manager for large website design and development projects. Experience at a digital creative agency is preferred. </p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">A demonstrated commitment to social impact issues and/or working in, with, or adjacent to the for-purpose sector is a major plus. The salary range is $52,000 to $68,000 depending on experience. This position is remote. US only. We prefer candidates in the EST timezone. There is an option to come into the office if you are based in the New York City area.</p>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>Key Responsibilities</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Manage multiple, concurrent projects from start to finish, incorporating Radish standards and processes in the delivery of client work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Create project plans, timelines, and manage day-to-day tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run weekly or bi-weekly client check in meetings and set and manage client expectations, communicating updates, and project progress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Coordinate creative reviews with the design team, vetting and communicating client feedback</p></li><li dir=\"ltr\"><p dir=\"ltr\">Triage incoming client requests, fielding questions, and determining appropriate solutions</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support website launches, QA new features and sites as needed</p></li><li dir=\"ltr\"><p dir=\"ltr\">Ensure that all project materials, documentation, and assets are organized properly</p></li><li dir=\"ltr\"><p dir=\"ltr\">Run post-project reviews and synthesize lessons learned to integrate into future projects and best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with CMS (eg. Wordpress or similar), design tools (eg. Figma or similar), and project management tools (eg. ClickUp) is preferred. </p></li></ul>\n<h3 dir=\"ltr\"><strong>Compensation, Perks + Benefits</strong></h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">The non-negotiable salary band for this position is $52,000 to $68,000 depending on experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">Medical, dental, and vision insurance with FSA/HSA options</p></li><li dir=\"ltr\"><p dir=\"ltr\">Available 401(k) plans and matching</p></li><li dir=\"ltr\"><p dir=\"ltr\">Opportunities for professional development</p></li><li dir=\"ltr\"><p dir=\"ltr\">We close two weeks for winter break</p></li><li dir=\"ltr\"><p dir=\"ltr\">Unlimited PTO</p></li><li dir=\"ltr\"><p dir=\"ltr\">An awesome culture that prioritizes work/life balance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Incentive program to encourage volunteer work</p></li><li dir=\"ltr\"><p dir=\"ltr\">Annual company retreat</p></li><li dir=\"ltr\"><p dir=\"ltr\">Friendly, hard-working, and supportive team</p></li></ul>\n<p dir=\"ltr\"><strong>For those located in NYC:</strong></p>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Pre-tax MTA Metrocards</p></li><li dir=\"ltr\"><p dir=\"ltr\">Free Citibike membership</p></li><li dir=\"ltr\"><p dir=\"ltr\">Discounts at NYC gyms</p></li></ul>\n<p dir=\"ltr\"><br /></p>\n<h3 dir=\"ltr\"><strong>About Radish Lab</strong></h3>\n<p dir=\"ltr\">Radish Lab launched in 2012 to work on projects we believe in, with clients we click with. And today, we’re still invested in much more than just the end-product.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">In our approach to working with clients we are committed to working:</p>\n<p dir=\"ltr\">With empathy, not ego.</p>\n<p dir=\"ltr\">With them, not for them.</p>\n<p dir=\"ltr\">With integrity, not just ideas.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">Radish Lab is an equal opportunity employer. Applicants will not be discriminated against because of race, color, creed, sex, sexual orientation, gender identity or expression, age, religion, national origin, citizenship status, disability, ancestry, marital status, veteran status, medical condition or any protected category prohibited by local, state or federal laws.<br /></p>\n\n<p><br /></p>","locations_question_required":true},{"cover_image":null,"company_name":"Radish Lab","id":1333509,"sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","options_photo":"optional","remote":true,"state_code":"NY","hybrid":false,"position":42,"location":"Remote job","close_at":null,"published_at":"2023-07-24 19:56:03 UTC","max_hours_per_week":"40.0","locations_question_type":"multiple_choice","on_site":false,"country":"United States","requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","mailbox_email":"job.pwpku@radishlab.recruitee.com","options_cv":"required","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","note":null,"postal_code":null,"street":null}},"country_code":"US","state_code":"NY","note":null,"postal_code":null,"street":null}],"careers_url":"https://radishlab.recruitee.com/o/developer-talent-pool","employment_type_code":"contract","experience_code":"mid_level","salary":{"max":null,"min":null,"period":null,"currency":null},"location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/developer-talent-pool/c/new","category_code":"technical","tags":[],"max_hours":null,"title":"Developer Talent Pool","country_code":"US","city":"New York","state_name":"New York","sharing_title":"Developer Talent Pool","status":"published","min_hours":null,"guid":"pwpku","department":"Development","open_questions":[{"id":1979954,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency environment? ","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency environment? "}},"open_question_options":[]},{"id":1979955,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?","kind":"boolean","translations":{"en":{"body":"Do you have experience with the Roots.io Sage starter theme/approach to developing WordPress sites?"}},"open_question_options":[]},{"id":1979956,"position":3,"options":{"length":120},"required":true,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":1979957,"position":4,"options":{"length":120},"required":true,"body":"Please provide your desired weekly rate for a full-time contract position.","kind":"string","translations":{"en":{"body":"Please provide your desired weekly rate for a full-time contract position."}},"open_question_options":[]},{"id":1979958,"position":5,"options":{"length":120},"required":true,"body":"City","kind":"string","translations":{"en":{"body":"City"}},"open_question_options":[]},{"id":1979959,"position":6,"options":{"length":120},"required":true,"body":"State/Region","kind":"string","translations":{"en":{"body":"State/Region"}},"open_question_options":[]},{"id":1979960,"position":7,"options":{"length":120},"required":true,"body":"Country","kind":"string","translations":{"en":{"body":"Country"}},"open_question_options":[]},{"id":1979961,"position":8,"options":{"length":120},"required":true,"body":"Where did you find out about this position?","kind":"string","translations":{"en":{"body":"Where did you find out about this position?"}},"open_question_options":[]},{"id":1979965,"position":9,"options":{"length":120},"required":true,"body":"Do you have 3+ years of professional experience developing complex WordPress websites? ","kind":"boolean","translations":{"en":{"body":"Do you have 3+ years of professional experience developing complex WordPress websites? "}},"open_question_options":[]},{"id":1979962,"position":10,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your GitHub profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your GitHub profile."}},"open_question_options":[]},{"id":1979963,"position":11,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your Stack Overflow profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your Stack Overflow profile."}},"open_question_options":[]},{"id":1979964,"position":12,"options":{"length":120},"required":false,"body":"Optional: Provide a link to your LinkedIn profile.","kind":"string","translations":{"en":{"body":"Optional: Provide a link to your LinkedIn profile."}},"open_question_options":[]},{"id":2036791,"position":13,"options":{"length":120},"required":false,"body":"Where are you more comfortable?","kind":"multi_choice","translations":{"en":{"body":"Where are you more comfortable?"}},"open_question_options":[{"id":2846492,"position":0,"body":"Back-end","translations":{"en":{"body":"Back-end"}}},{"id":2846493,"position":1,"body":"Front-end","translations":{"en":{"body":"Front-end"}}},{"id":2846494,"position":2,"body":"Full-stack","translations":{"en":{"body":"Full-stack"}}}]},{"id":2036792,"position":14,"options":{"length":120},"required":true,"body":"Do you have experience working with REST APIs?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with REST APIs?"}},"open_question_options":[]},{"id":2036794,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience using the MVC architectural pattern?","kind":"boolean","translations":{"en":{"body":"Do you have experience using the MVC architectural pattern?"}},"open_question_options":[]},{"id":2036795,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience working with a task management and time tracking system?","kind":"boolean","translations":{"en":{"body":"Do you have experience working with a task management and time tracking system?"}},"open_question_options":[]},{"id":2036796,"position":17,"options":{"length":120},"required":false,"body":"Provide links to the most recent websites you’ve built","kind":"string","translations":{"en":{"body":"Provide links to the most recent websites you’ve built"}},"open_question_options":[]},{"id":2036797,"position":18,"options":{"length":120},"required":false,"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position.","kind":"text","translations":{"en":{"body":"Please provide a link to your portfolio and a brief description of your involvement in projects you think are applicable to this position."}},"open_question_options":[]},{"id":2036798,"position":19,"options":{"length":120},"required":false,"body":"Do you live within 2-3 hours of EST?","kind":"boolean","translations":{"en":{"body":"Do you live within 2-3 hours of EST?"}},"open_question_options":[]},{"id":2070268,"position":20,"options":{"length":120},"required":false,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"multi_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2901176,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2901177,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2901178,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]}],"options_cover_letter":"optional","translations":{"en":{"description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","title":"Developer Talent Pool","sharing_image":null,"requirements":"<h4 dir=\"ltr\">Must Haves / Requirements</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">5+ years of professional experience developing complex WordPress websites</p></li><li dir=\"ltr\"><p dir=\"ltr\">5+ years of PHP and MySQL experience</p></li><li dir=\"ltr\"><p dir=\"ltr\">3+ years of frontend development experience, using HTML5, CSS/SASS, JavaScript frameworks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the MVC architectural pattern (Laravel, CakePHP, CodeIgniter, etc.)</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience managing composer and node packages within a project</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a Continuous Integration setup</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience working with a ticket manager and time tracking system</p></li><li dir=\"ltr\"><p dir=\"ltr\">Proficient in responsive web design and cross-browser compatibility best practices</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with git through the console</p></li><li dir=\"ltr\"><p dir=\"ltr\">Excellent communication skills in both verbal and written English</p></li><li dir=\"ltr\"><p dir=\"ltr\">MUST be in a timezone within 2-3 hours of New York (EST). Others will NOT be considered.</p></li></ul>\n<h4 dir=\"ltr\">Nice to Have</h4>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Experience in an agency environment</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with JavaScript libraries such as React, Vue, or Angular</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience developing websites that meet WCAG AA compliance</p></li><li dir=\"ltr\"><p dir=\"ltr\">Experience with Advanced Custom Fields</p></li><li dir=\"ltr\"><p dir=\"ltr\">Bachelor’s degree in Computer Science</p></li><li dir=\"ltr\"><p dir=\"ltr\">Interested in social change, and engaged with causes</p></li></ul>","sharing_title":"Developer Talent Pool","sharing_description":"Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.\n\nWe are seeking an experienced WordPress developer who is comfortable leadi","locations_question":"What is your preferred work location?"}},"postal_code":null,"sharing_image":null,"updated_at":"2024-06-30 19:58:06 UTC","created_at":"2023-05-31 13:38:00 UTC","education_code":"bachelor_degree","options_phone":"required","slug":"developer-talent-pool","locations_question":"What is your preferred work location?","min_hours_per_week":"30.0","description":"<p dir=\"ltr\">Radish Lab is a purpose-driven creative agency, shaping stories and sharpening brands for organizations improving the world.</p>\n<p dir=\"ltr\"><br /></p>\n<p dir=\"ltr\">We are seeking an experienced WordPress developer who is comfortable leading web projects. As a part of our development team you will work on numerous projects, translating design into clean and consistent code.</p>\n<p dir=\"ltr\">As a WordPress Developer, you will be responsible for developing and maintaining WordPress websites for our clients. The ideal candidate should have a strong understanding of WordPress, Laravel, Sass, and JavaScript. Optional knowledge of the Sage theme framework is a plus.</p>\n<p dir=\"ltr\">As a remote position, you will have the flexibility to work from anywhere. You will collaborate with our team of designers, developers, and project managers to create custom solutions for our clients. The ideal candidate should have excellent communication skills and be able to work independently.</p>\n<p dir=\"ltr\"><strong>Contract type</strong>: This is a remote full-time contract position. No agencies please.</p>\n<p dir=\"ltr\"><strong>Location</strong>: Preferably Latin or South America. MUST be in a timezone within two hours of New York (EST). Others will NOT be considered.</p>\n<h3 dir=\"ltr\">Responsibilities</h3>\n<ul><li dir=\"ltr\"><p dir=\"ltr\">Bring to life carefully designed visual layouts and user interactions using WordPress and the Roots.io Sage approach to WordPress</p></li><li dir=\"ltr\"><p dir=\"ltr\">Work to understand the design and functionality of a website in progress to be able to ask good questions of the project managers and designers early in the process</p></li><li dir=\"ltr\"><p dir=\"ltr\">Support teammates and collaborate with a \"do what it takes\" attitude</p></li><li dir=\"ltr\"><p dir=\"ltr\">Effectively prioritize and execute tasks</p></li><li dir=\"ltr\"><p dir=\"ltr\">Display strong communication skills (both in person and in writing) while interacting with individuals with a range of technical understanding</p></li><li dir=\"ltr\"><p dir=\"ltr\">Know when to ask for help</p></li></ul>\n<h3 dir=\"ltr\">Perks</h3>\n<p dir=\"ltr\">Full-time, international contractors enjoy many of the same perks as full-time Radish employees based in the US, including paid opportunities for professional development.</p>","locations_question_required":true},{"cover_image":null,"company_name":"Radish Lab","id":1333465,"sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","options_photo":"optional","remote":true,"state_code":"NY","hybrid":false,"position":41,"location":"Remote job","close_at":null,"published_at":"2023-07-24 19:56:30 UTC","max_hours_per_week":"40.0","locations_question_type":"multiple_choice","on_site":false,"country":"United States","requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","mailbox_email":"job.2ccy3@radishlab.recruitee.com","options_cv":"required","locations":[{"id":94692,"name":"New York","state":"New York","country":"United States","city":"New York","translations":{"en":{"name":"New York","city":"New York","note":null,"postal_code":null,"street":null}},"country_code":"US","state_code":"NY","note":null,"postal_code":null,"street":null}],"careers_url":"https://radishlab.recruitee.com/o/design-talent-pool","employment_type_code":"contract","experience_code":"mid_level","salary":{"max":null,"min":null,"period":null,"currency":null},"location_question_visible":false,"careers_apply_url":"https://radishlab.recruitee.com/o/design-talent-pool/c/new","category_code":"design","tags":[],"max_hours":null,"title":"Design Talent Pool","country_code":"US","city":"New York","state_name":"New York","sharing_title":"Design Talent Pool","status":"published","min_hours":null,"guid":"2ccy3","department":"Design","open_questions":[{"id":1941718,"position":1,"options":{"length":120},"required":true,"body":"Do you have experience working in an agency?","kind":"boolean","translations":{"en":{"body":"Do you have experience working in an agency?"}},"open_question_options":[]},{"id":1941724,"position":2,"options":{"length":120},"required":true,"body":"Do you have experience working on a small team?","kind":"boolean","translations":{"en":{"body":"Do you have experience working on a small team?"}},"open_question_options":[]},{"id":2069839,"position":3,"options":{},"required":true,"body":"Where are you located? (Helps us organize people based on time zone needed.)","kind":"single_choice","translations":{"en":{"body":"Where are you located? (Helps us organize people based on time zone needed.)"}},"open_question_options":[{"id":2900483,"position":0,"body":"North or South America","translations":{"en":{"body":"North or South America"}}},{"id":2900484,"position":1,"body":"Europe","translations":{"en":{"body":"Europe"}}},{"id":2900515,"position":2,"body":"Other","translations":{"en":{"body":"Other"}}}]},{"id":1941721,"position":4,"options":{"length":120},"required":true,"body":"Where are you located: City","kind":"string","translations":{"en":{"body":"Where are you located: City"}},"open_question_options":[]},{"id":1953017,"position":5,"options":{"length":120},"required":true,"body":"Where are you located: State/Region","kind":"string","translations":{"en":{"body":"Where are you located: State/Region"}},"open_question_options":[]},{"id":1953018,"position":6,"options":{"length":120},"required":true,"body":"Where are you located: Country","kind":"string","translations":{"en":{"body":"Where are you located: Country"}},"open_question_options":[]},{"id":1941716,"position":7,"options":{"length":120},"required":true,"body":"Do you have at least four years of experience working in design professionally?","kind":"boolean","translations":{"en":{"body":"Do you have at least four years of experience working in design professionally?"}},"open_question_options":[]},{"id":1941723,"position":8,"options":{"length":120},"required":true,"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time).","kind":"single_choice","translations":{"en":{"body":"If you are located in the US, are you authorized to work in the US? (We are not sponsoring visas at this time)."}},"open_question_options":[{"id":2688866,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688867,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688865,"position":2,"body":"N/A","translations":{"en":{"body":"N/A"}}}]},{"id":1941727,"position":9,"options":{"length":120},"required":true,"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)","kind":"single_choice","translations":{"en":{"body":"If you are outside of the US, are you authorized to work in the US? (We are not sponsoring visas at this time.)"}},"open_question_options":[{"id":2688871,"position":0,"body":"Yes","translations":{"en":{"body":"Yes"}}},{"id":2688870,"position":1,"body":"No","translations":{"en":{"body":"No"}}},{"id":2688872,"position":2,"body":"It's Complicated","translations":{"en":{"body":"It's Complicated"}}}]},{"id":1953032,"position":10,"options":{"length":120},"required":true,"body":"Are you proficient in English?","kind":"boolean","translations":{"en":{"body":"Are you proficient in English?"}},"open_question_options":[]},{"id":1941719,"position":11,"options":{"length":120},"required":true,"body":"Please share a link to your portfolio. No PDFs or google drive links. ","kind":"string","translations":{"en":{"body":"Please share a link to your portfolio. No PDFs or google drive links. "}},"open_question_options":[]},{"id":1949763,"position":12,"options":{"length":120},"required":true,"body":"Which of the following roles are you most qualified for?","kind":"single_choice","translations":{"en":{"body":"Which of the following roles are you most qualified for?"}},"open_question_options":[{"id":2701413,"position":0,"body":"UI Designer ","translations":{"en":{"body":"UI Designer "}}},{"id":2701414,"position":1,"body":"UX Designer ","translations":{"en":{"body":"UX Designer "}}},{"id":2701415,"position":2,"body":"Brand Designer ","translations":{"en":{"body":"Brand Designer "}}}]},{"id":1953033,"position":13,"options":{"length":120},"required":false,"body":"What additional roles are you interested in? ","kind":"multi_choice","translations":{"en":{"body":"What additional roles are you interested in? "}},"open_question_options":[{"id":2706667,"position":0,"body":"UX","translations":{"en":{"body":"UX"}}},{"id":2706668,"position":1,"body":"UI","translations":{"en":{"body":"UI"}}},{"id":2706669,"position":2,"body":"Branding","translations":{"en":{"body":"Branding"}}}]},{"id":1941717,"position":14,"options":{},"required":true,"body":"Are you proficient in Figma? ","kind":"boolean","translations":{"en":{"body":"Are you proficient in Figma? "}},"open_question_options":[]},{"id":1941720,"position":15,"options":{"length":120},"required":true,"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?","kind":"boolean","translations":{"en":{"body":"Do you have experience applying a creative direction to a wireframe with the end deliverable of a page design that was handed off to a developer?"}},"open_question_options":[]},{"id":1953034,"position":16,"options":{"length":120},"required":true,"body":"Do you have experience creating visual identities? ","kind":"boolean","translations":{"en":{"body":"Do you have experience creating visual identities? "}},"open_question_options":[]},{"id":1964495,"position":17,"options":{"length":120},"required":true,"body":"Do you have experience creating low-fidelity sitemaps and wireframes?","kind":"boolean","translations":{"en":{"body":"Do you have experience creating low-fidelity sitemaps and wireframes?"}},"open_question_options":[]},{"id":1953035,"position":18,"options":{"length":120},"required":true,"body":"Which of the following role types are you open to:","kind":"multi_choice","translations":{"en":{"body":"Which of the following role types are you open to:"}},"open_question_options":[{"id":2706672,"position":0,"body":"Full Time","translations":{"en":{"body":"Full Time"}}},{"id":2706673,"position":1,"body":"Short-term Freelance ","translations":{"en":{"body":"Short-term Freelance "}}},{"id":2706674,"position":2,"body":"Long-term Freelance ","translations":{"en":{"body":"Long-term Freelance "}}}]},{"id":1953044,"position":19,"options":{"length":120},"required":true,"body":"If freelance, what is your hourly rate? ","kind":"string","translations":{"en":{"body":"If freelance, what is your hourly rate? "}},"open_question_options":[]},{"id":1964494,"position":20,"options":{"length":120},"required":true,"body":"If full-time, what is your expected salary range? ","kind":"string","translations":{"en":{"body":"If full-time, what is your expected salary range? "}},"open_question_options":[]},{"id":1941725,"position":21,"options":{"length":120},"required":true,"body":"How many weeks would you need between receiving a job offer and starting the job?","kind":"text","translations":{"en":{"body":"How many weeks would you need between receiving a job offer and starting the job?"}},"open_question_options":[]},{"id":1941726,"position":22,"options":{"length":120},"required":true,"body":"How did you hear about Radish?","kind":"text","translations":{"en":{"body":"How did you hear about Radish?"}},"open_question_options":[]}],"options_cover_letter":"optional","translations":{"en":{"description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","title":"Design Talent Pool","sharing_image":null,"requirements":"<ul><li>Minimum of 4 years professional design experience </li><li>Comfortable working on a small team </li><li>Excellent knowledge of Figma </li><li>Experience with either UX or UI in a professional capacity </li></ul>","sharing_title":"Design Talent Pool","sharing_description":"We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freela","locations_question":"What is your preferred work location?"}},"postal_code":null,"sharing_image":null,"updated_at":"2024-07-10 01:26:39 UTC","created_at":"2023-05-31 13:19:38 UTC","education_code":"bachelor_degree","options_phone":"required","slug":"design-talent-pool","locations_question":"What is your preferred work location?","min_hours_per_week":"30.0","description":"<p>We are always looking for passionate, talented designers to join our team but don't always have an opening. Apply through this position to join our Talent Pool! Whenever we have new openings or freelance opportunities we start with individuals who have applied via our Talent Pool. If we think you are a good fit, we'll reach out to schedule time to chat. <br /><br />The Design Talent Pool will be used as a pipeline for UX, UI, and Branding positions at Radish. All applicants should have a minimum of 4 years of professional design experience, know Figma inside and out, and be comfortable working on a small team. Our Design team is small but mighty, so communication and collaboration are key.</p>","locations_question_required":true}]}
+  recorded_at: Tue, 30 Jul 2024 16:28:54 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/BROOKLYN,%20New%20Y?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -259,7 +259,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:07:04 GMT
+      - Tue, 30 Jul 2024 16:28:55 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -277,18 +277,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 5a70250a81e344e495e485c93427c804
+      - 61ad041a87f70593a2e304b5ec848343
       X-Msedge-Ref:
-      - 'Ref A: 1CFEB2D414E649839208D90284D84662 Ref B: DB3EDGE2920 Ref C: 2024-07-29T09:07:04Z|Ref
-        SnR: 66a75bb8ff214eaebe7448491489c1bd'
+      - 'Ref SnR: 66a914c76a2347efb00abe34c2aaa417|Ref A: 0C564FF44FA040B28CE8A5D4534D6F6B
+        Ref B: DB3EDGE2513 Ref C: 2024-07-30T16:28:55Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-7sjlk, mapsplatform-forwardgeocoder-service-69c675d4f5-zv2qg
+      - mapsplatform-frontend-5989d449fd-wr4h9, mapsplatform-forwardgeocoder-service-69c675d4f5-9fk55
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '65'
+      - '69'
       X-Azure-Ref:
-      - 20240729T090704Z-154b59dbc6d4k5kgvkz7d10808000000097g000000019dpd
+      - 20240730T162855Z-154b59dbc6d5lqv7gb5ha8t1mw00000005qg00000000zs4g
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -296,8 +296,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzM5LjY2NDA3NjE4NjgzMTY2NCwtNzQuOTkzMDU2OTMyMzI3MjUsMzkuNzIyMDE2OTUyODE2NzcsLTc0Ljg5MjcwMDUxMzk2MTgxXSwibmFtZSI6Ik5ldyBCcm9va2x5biwgTkoiLCJwb2ludCI6eyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM5LjY5MzA0NjU3LC03NC45NDI4Nzg3Ml19LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJOSiIsImFkbWluRGlzdHJpY3QyIjoiR2xvdWNlc3RlciBDb3VudHkiLCJjb3VudHJ5UmVnaW9uIjoiVW5pdGVkIFN0YXRlcyIsImZvcm1hdHRlZEFkZHJlc3MiOiJOZXcgQnJvb2tseW4sIE5KIiwibG9jYWxpdHkiOiJOZXcgQnJvb2tseW4ifSwiY29uZmlkZW5jZSI6IkxvdyIsImVudGl0eVR5cGUiOiJQb3B1bGF0ZWRQbGFjZSIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbMzkuNjkzMDQ2NTcsLTc0Ljk0Mjg3ODcyXSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19XX1dLCJzdGF0dXNDb2RlIjoyMDAsInN0YXR1c0Rlc2NyaXB0aW9uIjoiT0siLCJ0cmFjZUlkIjoiNWE3MDI1MGE4MWUzNDRlNDk1ZTQ4NWM5MzQyN2M4MDQifQ==
-  recorded_at: Mon, 29 Jul 2024 09:07:04 GMT
+        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzM5LjY2NDA3NjE4NjgzMTY2NCwtNzQuOTkzMDU2OTMyMzI3MjUsMzkuNzIyMDE2OTUyODE2NzcsLTc0Ljg5MjcwMDUxMzk2MTgxXSwibmFtZSI6Ik5ldyBCcm9va2x5biwgTkoiLCJwb2ludCI6eyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM5LjY5MzA0NjU3LC03NC45NDI4Nzg3Ml19LCJhZGRyZXNzIjp7ImFkbWluRGlzdHJpY3QiOiJOSiIsImFkbWluRGlzdHJpY3QyIjoiR2xvdWNlc3RlciBDb3VudHkiLCJjb3VudHJ5UmVnaW9uIjoiVW5pdGVkIFN0YXRlcyIsImZvcm1hdHRlZEFkZHJlc3MiOiJOZXcgQnJvb2tseW4sIE5KIiwibG9jYWxpdHkiOiJOZXcgQnJvb2tseW4ifSwiY29uZmlkZW5jZSI6IkxvdyIsImVudGl0eVR5cGUiOiJQb3B1bGF0ZWRQbGFjZSIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbMzkuNjkzMDQ2NTcsLTc0Ljk0Mjg3ODcyXSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19XX1dLCJzdGF0dXNDb2RlIjoyMDAsInN0YXR1c0Rlc2NyaXB0aW9uIjoiT0siLCJ0cmFjZUlkIjoiNjFhZDA0MWE4N2Y3MDU5M2EyZTMwNGI1ZWM4NDgzNDMifQ==
+  recorded_at: Tue, 30 Jul 2024 16:28:55 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/k,%20United%20States?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -317,7 +317,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:07:04 GMT
+      - Tue, 30 Jul 2024 16:28:55 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -335,18 +335,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 383db3137ad8eb78221b42fe6f6900f3
+      - 9ee0ea880b580f2c38d6fc2df8a623df
       X-Msedge-Ref:
-      - 'Ref A: 50500059DFD14D08B85263CC0DE2294B Ref B: DB3EDGE2007 Ref C: 2024-07-29T09:07:04Z|Ref
-        SnR: 66a75bb81c0540c1ad3906cab261dd2c'
+      - 'Ref SnR: 66a914c7c2da41d68d89bc0daca9d75a|Ref A: 4FA0BE747B324D48A1526972E4F96EA8
+        Ref B: DB3EDGE3211 Ref C: 2024-07-30T16:28:55Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-8z5f6, mapsplatform-forwardgeocoder-service-69c675d4f5-5qklk
+      - mapsplatform-frontend-5989d449fd-79dtw, mapsplatform-forwardgeocoder-service-69c675d4f5-6d962
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '66'
+      - '70'
       X-Azure-Ref:
-      - 20240729T090704Z-17cc7bff7589r94673g4ny45gs00000005c000000000e84v
+      - 20240730T162855Z-154b59dbc6dbfz5w4e0zaun7z400000009z000000001a0qv
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -354,6 +354,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzI1LjE0NjAxMzI1OTg4NzY5NSwtMTI0Ljc5MDc1NjIyNTU4NTk0LDQ5LjM4NDM1NzQ1MjM5MjU4LC02Ni45NzAzOTc5NDkyMTg3NV0sIm5hbWUiOiJVbml0ZWQgU3RhdGVzIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlszOS41MDM1NzA1NiwtOTkuMDE4MzQxMDZdfSwiYWRkcmVzcyI6eyJjb3VudHJ5UmVnaW9uIjoiVW5pdGVkIFN0YXRlcyIsImZvcm1hdHRlZEFkZHJlc3MiOiJVbml0ZWQgU3RhdGVzIn0sImNvbmZpZGVuY2UiOiJIaWdoIiwiZW50aXR5VHlwZSI6IkNvdW50cnlSZWdpb24iLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM5LjUwMzU3MDU2LC05OS4wMTgzNDEwNl0sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfV19XSwic3RhdHVzQ29kZSI6MjAwLCJzdGF0dXNEZXNjcmlwdGlvbiI6Ik9LIiwidHJhY2VJZCI6IjM4M2RiMzEzN2FkOGViNzgyMjFiNDJmZTZmNjkwMGYzIn0=
-  recorded_at: Mon, 29 Jul 2024 09:07:04 GMT
+        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzI1LjE0NjAxMzI1OTg4NzY5NSwtMTI0Ljc5MDc1NjIyNTU4NTk0LDQ5LjM4NDM1NzQ1MjM5MjU4LC02Ni45NzAzOTc5NDkyMTg3NV0sIm5hbWUiOiJVbml0ZWQgU3RhdGVzIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlszOS41MDM1NzA1NiwtOTkuMDE4MzQxMDZdfSwiYWRkcmVzcyI6eyJjb3VudHJ5UmVnaW9uIjoiVW5pdGVkIFN0YXRlcyIsImZvcm1hdHRlZEFkZHJlc3MiOiJVbml0ZWQgU3RhdGVzIn0sImNvbmZpZGVuY2UiOiJIaWdoIiwiZW50aXR5VHlwZSI6IkNvdW50cnlSZWdpb24iLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM5LjUwMzU3MDU2LC05OS4wMTgzNDEwNl0sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfV19XSwic3RhdHVzQ29kZSI6MjAwLCJzdGF0dXNEZXNjcmlwdGlvbiI6Ik9LIiwidHJhY2VJZCI6IjllZTBlYTg4MGI1ODBmMmMzOGQ2ZmMyZGY4YTYyM2RmIn0=
+  recorded_at: Tue, 30 Jul 2024 16:28:55 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_smartrecruiters.yml b/spec/fixtures/cassettes/create_job_smartrecruiters.yml
index 2ccdc3af..89308c42 100644
--- a/spec/fixtures/cassettes/create_job_smartrecruiters.yml
+++ b/spec/fixtures/cassettes/create_job_smartrecruiters.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:10:05 GMT
+      - Tue, 30 Jul 2024 16:28:55 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -27,10 +27,10 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - AWSALB=rDMM7McSHRv08aj1LJB3ivWONqtOTuw3AbIjfxQWKmgxnuNzFDorucLt37mHVKmJwoNpeMQXVFy7YAPfHBmafnE574z9YDAXdRaAwJ3KBcDFmOm2Bi01abYtPyU2;
-        Expires=Mon, 05 Aug 2024 09:10:05 GMT; Path=/
-      - AWSALBCORS=rDMM7McSHRv08aj1LJB3ivWONqtOTuw3AbIjfxQWKmgxnuNzFDorucLt37mHVKmJwoNpeMQXVFy7YAPfHBmafnE574z9YDAXdRaAwJ3KBcDFmOm2Bi01abYtPyU2;
-        Expires=Mon, 05 Aug 2024 09:10:05 GMT; Path=/; SameSite=None; Secure
+      - AWSALB=W65ZoCEF7A0VY8JiRJwpPcAcm6E25bn542KHGNzc2c+JNyztHx1yH/aReu/vnmzF1VPiByJ/vSyn1I1UrBp/Pwab+vHEggoLbW7vzK7biQMHe+TeMHqqEiLBP7bV;
+        Expires=Tue, 06 Aug 2024 16:28:55 GMT; Path=/
+      - AWSALBCORS=W65ZoCEF7A0VY8JiRJwpPcAcm6E25bn542KHGNzc2c+JNyztHx1yH/aReu/vnmzF1VPiByJ/vSyn1I1UrBp/Pwab+vHEggoLbW7vzK7biQMHe+TeMHqqEiLBP7bV;
+        Expires=Tue, 06 Aug 2024 16:28:55 GMT; Path=/; SameSite=None; Secure
       Dcr-Decision-By:
       - public-posting-api
       Dcr-Processing-Time-Ms:
@@ -40,7 +40,7 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Etag:
-      - W/"c5a9-tmL+EiWr0pgat2hhK4D4zDLHX8s"
+      - W/"98d5-Z9K0gezRb5N1xzbbI8kxhLbIWCk"
       Datacenter:
       - fran
       Strict-Transport-Security:
@@ -54,11 +54,25 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabf94bdfcabee9-LHR
+      - 8ab6b980b8e1949d-LHR
     body:
       encoding: ASCII-8BIT
-      string: '{"offset":0,"limit":100,"totalFound":18,"content":[{"id":"744000003338800","name":"Food
-        Technical Administrator - (12 Month Fixed Term Contract)","uuid":"5646d6c7-574b-4322-b34c-fda5c3d5aeb0","jobAdId":"47bf63d9-ac4e-44c9-9c37-2703577b6e4d","defaultJobAd":true,"refNumber":"000000000578","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T08:51:00.002Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
+      string: '{"offset":0,"limit":100,"totalFound":14,"content":[{"id":"744000003360384","name":"Junior
+        Technical Artworker - (12 Month Fixed Term Contract)","uuid":"d67d464f-923c-4e6c-8a94-55113df4dd68","jobAdId":"862af3c0-0fd6-4041-8bd7-5e1c1a3c8e1b","defaultJobAd":true,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T10:18:30.916Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
+        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
+        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
+        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
+        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
+        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
+        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
+        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
+        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
+        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
+        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
+        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
+        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003360384","language":{"code":"en","label":"English","labelNative":"English
+        (US)"}},{"id":"744000003338800","name":"Food Technical Administrator - (12
+        Month Fixed Term Contract)","uuid":"5646d6c7-574b-4322-b34c-fda5c3d5aeb0","jobAdId":"47bf63d9-ac4e-44c9-9c37-2703577b6e4d","defaultJobAd":true,"refNumber":"000000000578","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T08:51:00.002Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
         Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
         Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
@@ -98,36 +112,6 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"28000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"Tara Abboud"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003335215","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000003218005","name":"Junior Technical Artworker - (12 Month
-        Fixed Term Contract)","uuid":"ac45b3c0-efce-406b-aced-638d8ba90846","jobAdId":"862af3c0-0fd6-4041-8bd7-5e1c1a3c8e1b","defaultJobAd":true,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-27T08:17:24.961Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003218005","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000003217965","name":"Junior Technical Artworker - (12 Month
-        Fixed Term Contract)","uuid":"bd4d1d8c-18e2-428c-bad1-ac75c55524c3","jobAdId":"73a77ffc-84c8-47fc-9655-91ccff9f0c72","defaultJobAd":false,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-27T08:16:39.707Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003217965","language":{"code":"en","label":"English","labelNative":"English
         (US)"}},{"id":"744000002592247","name":"Warehouse Team Leader","uuid":"9430262b-497f-4913-956a-3810227a6aae","jobAdId":"c1e22017-3b58-4d31-996d-4981c990c017","defaultJobAd":true,"refNumber":"REF557M","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T15:58:22.621Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"manufacturing","label":"Manufacturing"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost
         centre","valueId":"6ce5a87a-fa2e-4b22-92a2-1e2d0d33b853","valueLabel":"C6200"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
@@ -151,20 +135,6 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"38200 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"Jamie Tointon"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002567175","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000002516325","name":"QA Manager","uuid":"7b1d3b45-b557-42e1-b559-22866054da08","jobAdId":"980a4b7c-d00d-4000-a8b0-e6779e1e4a22","defaultJobAd":true,"refNumber":"000000000449","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T10:07:36.454Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"88d8ccdd-8459-4264-b8a2-5c8e7edb2197","valueLabel":"Foundations"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"31500 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Joanna Frankowska"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002516325","language":{"code":"en","label":"English","labelNative":"English
         (US)"}},{"id":"744000002509176","name":"Multimedia Content Creator - (6 month
         Fixed Term Contract)","uuid":"a59f7ad5-965a-46b5-b4bb-da0ddd545d84","jobAdId":"9a077858-fda3-416b-b911-f3af7a1cdef3","defaultJobAd":true,"refNumber":"000000000530","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T09:50:33.260Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
@@ -288,37 +258,8 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"95000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"James Carson"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002498002","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000002498534","name":"iOS Developer","uuid":"89fee71a-9098-4a25-8ddf-58cb10134477","jobAdId":"7aa456f0-4296-4fe3-b85f-17fa8d8a2e2d","defaultJobAd":true,"refNumber":"000000000535","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T08:49:31.661Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"b2c16d92-d5b0-4389-abdf-8ac9e31e4935","valueLabel":"Tech
-        Level 2"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"bf5b9a5d-9705-4d96-a909-742091f5f1cc","valueLabel":"Expand"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"f55dbcfa-4ee0-4022-8fba-9ed0fd62508d","valueLabel":"Software
-        Engineering - iOS"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"ea2db863-e8a2-4ecd-a924-e4976ee9059b","valueLabel":"New
-        Markets"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"8896b943-e635-423d-abd1-fe06e3c75f8d","valueLabel":"C8100"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"1cdd887e-233c-4bcb-89b6-f0fccc93ba2c","valueLabel":"Ireland
-        2"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career track","valueId":"328b8cfa-6440-47fa-9283-64be12b08b13","valueLabel":"Software
-        Engineering - Career Track"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"63000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Arjun Sathe"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002498534","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000000526675","name":"Production Supervisor, Nights (R)","uuid":"1404f33e-0743-4890-9055-80d86f199ad3","jobAdId":"54528012-4f1d-4fcf-b711-90513477f221","defaultJobAd":true,"refNumber":"000000000479","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-15T17:26:12.655Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"production","label":"Production"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"d7da8bb0-a7a6-4695-9090-ccd265bfe159","valueLabel":"Default"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f7c15500-dc0f-4ce6-84aa-34f7682262ec","valueLabel":"Operations
-        Fulfilment"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"ceaf9ff8-3d53-47a1-b3dc-fb41178686f3","valueLabel":"C6000"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"39000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Clare Baker"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000000526675","language":{"code":"en","label":"English","labelNative":"English
         (US)"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:10:05 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:55 GMT
 - request:
     method: get
     uri: https://api.smartrecruiters.com/v1/companies/Gousto1/postings
@@ -338,7 +279,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:10:05 GMT
+      - Tue, 30 Jul 2024 16:28:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -346,10 +287,10 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - AWSALB=5SlxkzRdE2TxQyiMKnUAEmcIVEzTukyq3r/R71d6zjOzaiGs4XefQ3S+yXDESbWivnxn4IvXw81qdZwDebGCjH/yOo9A2BteoSU0F3HuUkDdZp1IkCP/NEttkph9;
-        Expires=Mon, 05 Aug 2024 09:10:05 GMT; Path=/
-      - AWSALBCORS=5SlxkzRdE2TxQyiMKnUAEmcIVEzTukyq3r/R71d6zjOzaiGs4XefQ3S+yXDESbWivnxn4IvXw81qdZwDebGCjH/yOo9A2BteoSU0F3HuUkDdZp1IkCP/NEttkph9;
-        Expires=Mon, 05 Aug 2024 09:10:05 GMT; Path=/; SameSite=None; Secure
+      - AWSALB=hSHr7pQ3oZfZNueTmHTE8ZDo4Z3p3Q6b/lSsC2ztsBHrp9Ic2mI6EvZJ9O/eNqj5w7o6F4sRpb8DqcJpJ7oGe2eANeQxw5NveyuyyD6mrTWeJFAFQd/bZAP4+nsq;
+        Expires=Tue, 06 Aug 2024 16:28:55 GMT; Path=/
+      - AWSALBCORS=hSHr7pQ3oZfZNueTmHTE8ZDo4Z3p3Q6b/lSsC2ztsBHrp9Ic2mI6EvZJ9O/eNqj5w7o6F4sRpb8DqcJpJ7oGe2eANeQxw5NveyuyyD6mrTWeJFAFQd/bZAP4+nsq;
+        Expires=Tue, 06 Aug 2024 16:28:55 GMT; Path=/; SameSite=None; Secure
       Dcr-Decision-By:
       - public-posting-api
       Dcr-Processing-Time-Ms:
@@ -359,7 +300,7 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Etag:
-      - W/"c5a9-tmL+EiWr0pgat2hhK4D4zDLHX8s"
+      - W/"98d5-Z9K0gezRb5N1xzbbI8kxhLbIWCk"
       Datacenter:
       - fran
       Strict-Transport-Security:
@@ -373,11 +314,25 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabf94cbdbd8883-LHR
+      - 8ab6b9817e453853-LHR
     body:
       encoding: ASCII-8BIT
-      string: '{"offset":0,"limit":100,"totalFound":18,"content":[{"id":"744000003338800","name":"Food
-        Technical Administrator - (12 Month Fixed Term Contract)","uuid":"5646d6c7-574b-4322-b34c-fda5c3d5aeb0","jobAdId":"47bf63d9-ac4e-44c9-9c37-2703577b6e4d","defaultJobAd":true,"refNumber":"000000000578","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T08:51:00.002Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
+      string: '{"offset":0,"limit":100,"totalFound":14,"content":[{"id":"744000003360384","name":"Junior
+        Technical Artworker - (12 Month Fixed Term Contract)","uuid":"d67d464f-923c-4e6c-8a94-55113df4dd68","jobAdId":"862af3c0-0fd6-4041-8bd7-5e1c1a3c8e1b","defaultJobAd":true,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T10:18:30.916Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
+        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
+        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
+        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
+        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
+        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
+        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
+        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
+        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
+        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
+        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
+        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
+        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003360384","language":{"code":"en","label":"English","labelNative":"English
+        (US)"}},{"id":"744000003338800","name":"Food Technical Administrator - (12
+        Month Fixed Term Contract)","uuid":"5646d6c7-574b-4322-b34c-fda5c3d5aeb0","jobAdId":"47bf63d9-ac4e-44c9-9c37-2703577b6e4d","defaultJobAd":true,"refNumber":"000000000578","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-29T08:51:00.002Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
         Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
         Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
@@ -417,36 +372,6 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"28000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"Tara Abboud"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003335215","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000003218005","name":"Junior Technical Artworker - (12 Month
-        Fixed Term Contract)","uuid":"ac45b3c0-efce-406b-aced-638d8ba90846","jobAdId":"862af3c0-0fd6-4041-8bd7-5e1c1a3c8e1b","defaultJobAd":true,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-27T08:17:24.961Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003218005","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000003217965","name":"Junior Technical Artworker - (12 Month
-        Fixed Term Contract)","uuid":"bd4d1d8c-18e2-428c-bad1-ac75c55524c3","jobAdId":"73a77ffc-84c8-47fc-9655-91ccff9f0c72","defaultJobAd":false,"refNumber":"000000000574","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-27T08:16:39.707Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Sarah Fancourt"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003217965","language":{"code":"en","label":"English","labelNative":"English
         (US)"}},{"id":"744000002592247","name":"Warehouse Team Leader","uuid":"9430262b-497f-4913-956a-3810227a6aae","jobAdId":"c1e22017-3b58-4d31-996d-4981c990c017","defaultJobAd":true,"refNumber":"REF557M","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T15:58:22.621Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"manufacturing","label":"Manufacturing"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"associate","label":"Associate"},"customField":[{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost
         centre","valueId":"6ce5a87a-fa2e-4b22-92a2-1e2d0d33b853","valueLabel":"C6200"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
@@ -470,20 +395,6 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"38200 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"Jamie Tointon"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002567175","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000002516325","name":"QA Manager","uuid":"7b1d3b45-b557-42e1-b559-22866054da08","jobAdId":"980a4b7c-d00d-4000-a8b0-e6779e1e4a22","defaultJobAd":true,"refNumber":"000000000449","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T10:07:36.454Z","location":{"city":"Warrington","region":"England","country":"gb","remote":false,"latitude":"53.39203999999999","longitude":"-2.6023453"},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"88d8ccdd-8459-4264-b8a2-5c8e7edb2197","valueLabel":"Foundations"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food
-        Technical"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"31500 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Joanna Frankowska"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002516325","language":{"code":"en","label":"English","labelNative":"English
         (US)"}},{"id":"744000002509176","name":"Multimedia Content Creator - (6 month
         Fixed Term Contract)","uuid":"a59f7ad5-965a-46b5-b4bb-da0ddd545d84","jobAdId":"9a077858-fda3-416b-b911-f3af7a1cdef3","defaultJobAd":true,"refNumber":"000000000530","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T09:50:33.260Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
         And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
@@ -607,40 +518,11 @@ http_interactions:
         hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
         Annual Salary","valueLabel":"95000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
         Hiring Manager","valueLabel":"James Carson"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002498002","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000002498534","name":"iOS Developer","uuid":"89fee71a-9098-4a25-8ddf-58cb10134477","jobAdId":"7aa456f0-4296-4fe3-b85f-17fa8d8a2e2d","defaultJobAd":true,"refNumber":"000000000535","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-24T08:49:31.661Z","location":{"city":"London","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"information_technology","label":"Information
-        Technology"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"b2c16d92-d5b0-4389-abdf-8ac9e31e4935","valueLabel":"Tech
-        Level 2"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"bf5b9a5d-9705-4d96-a909-742091f5f1cc","valueLabel":"Expand"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"f55dbcfa-4ee0-4022-8fba-9ed0fd62508d","valueLabel":"Software
-        Engineering - iOS"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"ea2db863-e8a2-4ecd-a924-e4976ee9059b","valueLabel":"New
-        Markets"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"8896b943-e635-423d-abd1-fe06e3c75f8d","valueLabel":"C8100"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"1cdd887e-233c-4bcb-89b6-f0fccc93ba2c","valueLabel":"Ireland
-        2"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career track","valueId":"328b8cfa-6440-47fa-9283-64be12b08b13","valueLabel":"Software
-        Engineering - Career Track"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"63000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Arjun Sathe"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000002498534","language":{"code":"en","label":"English","labelNative":"English
-        (US)"}},{"id":"744000000526675","name":"Production Supervisor, Nights (R)","uuid":"1404f33e-0743-4890-9055-80d86f199ad3","jobAdId":"54528012-4f1d-4fcf-b711-90513477f221","defaultJobAd":true,"refNumber":"000000000479","company":{"identifier":"Gousto1","name":"Gousto"},"releasedDate":"2024-07-15T17:26:12.655Z","location":{"city":"Warrington","country":"gb","remote":false},"industry":{"id":"food_and_beverages","label":"Food
-        And Beverages"},"department":{},"function":{"id":"production","label":"Production"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"experienceLevel":{"id":"mid_senior_level","label":"Mid-Senior
-        Level"},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No
-        Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay
-        frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"d7da8bb0-a7a6-4695-9090-ccd265bfe159","valueLabel":"Default"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f7c15500-dc0f-4ce6-84aa-34f7682262ec","valueLabel":"Operations
-        Fulfilment"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"ceaf9ff8-3d53-47a1-b3dc-fb41178686f3","valueLabel":"C6000"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee
-        Type","valueId":"FTE","valueLabel":"FTE - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential
-        Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United
-        Kingdom"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career
-        track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted
-        hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum
-        Annual Salary","valueLabel":"39000 GBP"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful
-        Hiring Manager","valueLabel":"Clare Baker"}],"visibility":"PUBLIC","ref":"https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000000526675","language":{"code":"en","label":"English","labelNative":"English
         (US)"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:10:05 GMT
+  recorded_at: Tue, 30 Jul 2024 16:28:55 GMT
 - request:
     method: get
-    uri: https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003338800
+    uri: https://api.smartrecruiters.com/v1/companies/Gousto1/postings/744000003360384
     body:
       encoding: US-ASCII
       string: ''
@@ -657,7 +539,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:10:05 GMT
+      - Tue, 30 Jul 2024 16:28:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -665,10 +547,10 @@ http_interactions:
       Connection:
       - keep-alive
       Set-Cookie:
-      - AWSALB=1iprbGP2x7V2j3avUyszKEBYCu4305xSCyvC+rAmq0s26rsKkxygXoBVo55ilVeOIeqYTIlX6dU4GhvzLerswMfXn+VUO8q/pUlXgJcDS1RNdOaYrqDGAEhRwNzg;
-        Expires=Mon, 05 Aug 2024 09:10:05 GMT; Path=/
-      - AWSALBCORS=1iprbGP2x7V2j3avUyszKEBYCu4305xSCyvC+rAmq0s26rsKkxygXoBVo55ilVeOIeqYTIlX6dU4GhvzLerswMfXn+VUO8q/pUlXgJcDS1RNdOaYrqDGAEhRwNzg;
-        Expires=Mon, 05 Aug 2024 09:10:05 GMT; Path=/; SameSite=None; Secure
+      - AWSALB=9epDckU6MmWHH6B7repAhV7PJxfemMDHKnG3UQTSPzHGezxTh4/e3qQC5QWLfJezHmfcaio1XA6uaxeySDbgNkUCp6Nj0UNwFLsnPhwCBbIpWKTMBLwNgxvrBOgm;
+        Expires=Tue, 06 Aug 2024 16:28:56 GMT; Path=/
+      - AWSALBCORS=9epDckU6MmWHH6B7repAhV7PJxfemMDHKnG3UQTSPzHGezxTh4/e3qQC5QWLfJezHmfcaio1XA6uaxeySDbgNkUCp6Nj0UNwFLsnPhwCBbIpWKTMBLwNgxvrBOgm;
+        Expires=Tue, 06 Aug 2024 16:28:56 GMT; Path=/; SameSite=None; Secure
       Dcr-Decision-By:
       - public-posting-api
       Dcr-Processing-Time-Ms:
@@ -678,7 +560,7 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Etag:
-      - W/"1b72-A4hfGS7I0a5e5ba3qbxJb4xDRwA"
+      - W/"1f43-LxvagW+rk5eQlo+lKDakPKQqn3E"
       Datacenter:
       - fran
       Strict-Transport-Security:
@@ -692,15 +574,15 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabf94e1bb863e4-LHR
+      - 8ab6b9824ea276cb-LHR
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"id":"744000003338800","name":"Food Technical Administrator - (12 Month Fixed Term Contract)","uuid":"5646d6c7-574b-4322-b34c-fda5c3d5aeb0","jobId":"3cf47559-6749-4baf-a264-52b6f2c163e1","jobAdId":"47bf63d9-ac4e-44c9-9c37-2703577b6e4d","defaultJobAd":true,"refNumber":"000000000578","company":{"name":"Gousto","identifier":"Gousto1"},"location":{"city":"Warrington","country":"gb","remote":false},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"d7da8bb0-a7a6-4695-9090-ccd265bfe159","valueLabel":"Default"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food Technical"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful Hiring Manager","valueLabel":"Sarah Fancourt"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United Kingdom"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"}],"releasedDate":"2024-07-29T08:51:00.002Z","creator":{"name":"","avatarUrl":""},"postingUrl":"https://jobs.smartrecruiters.com/Gousto1/744000003338800-food-technical-administrator-12-month-fixed-term-contract-","applyUrl":"https://jobs.smartrecruiters.com/Gousto1/744000003338800-food-technical-administrator-12-month-fixed-term-contract-?oga=true","referralUrl":"https://jobs.smartrecruiters.com/external-referrals/company/Gousto1/publication/5646d6c7-574b-4322-b34c-fda5c3d5aeb0?dcr_ci=Gousto1","jobAd":{"sections":{"companyDescription":{"title":"Company Description","text":"<p>Here at Gousto, we are on a mission to become the UK's most loved way to eat dinner, and for every meal to leave the planet better off. Gousto is changing how people shop, cook and eat food at home. It’s an incredibly exciting time to join our team - and we’re a friendly bunch!</p><p>We’re proud to be one of the fastest-growing companies in the UK. Powered by data and a love of food, we’re a recipe box company that’s disrupting the sector, and we’re passionate about our diverse team and our customers.</p><p>All of our people are responsible for the success of Gousto, and we’re passionate about creating an inclusive environment for all to thrive. Our guiding values - Dream, Deliver and Care - show our commitment to innovation, our ambition to hit goals at speed, and our deep respect for the people we work with.</p>"},"jobDescription":{"title":"Job Description","text":"<p>We have an opportunity within Food Technical for a Food Technical Administrator to join our Food Process team.</p><p>The role will be hybrid, based in our Warrington site at least a couple of days per week.</p><p>The role consists of reviewing and updating recipes within our recipe library, working with a driven team to align and implement changes on a recipe by recipe basis. This is a routine-task based, desk-driven, position.</p><p>If you’re a naturally organised, detail-focused individual who excels at and finds satisfaction in structured tasks, you will fit right in.</p><p><strong>Core Responsibilities:</strong></p><ul><li>Recipe library management:<ul><li>Undertake the thorough checking and amendment of recipes following a defined set of rules</li><li>Identify anomalies within recipes, working with a close-knit team to align on resolutions and update recipes accordingly</li></ul></li><li>Food Safety:<ul><li>Raise awareness and compliance with food safety, allergens and nutritional information</li></ul></li></ul><p><strong>Who you are:</strong></p><ul><li>Proven experience in administration</li><li>Understanding &amp; awareness of food safety principles</li><li>Strong organisational skills</li><li>Excellent attention to detail</li><li>Ability to work at pace</li><li>Great time management skills</li><li>High level of written and spoken English</li><li>Clear communicator</li><li>Takes responsibility for managing the standard and quality of own output</li><li>Nice to haves:<ul><li>Food Technical Specification checking experience</li><li>Experience working within a Food Technology and/or administration role</li><li>Educated to HND/HNC level in a food-related subject</li></ul></li></ul>"},"qualifications":{"title":"Qualifications","text":""},"additionalInformation":{"title":"Additional Information","text":"<p><strong>Benefits:</strong></p><p>Click here to see our company<strong> <a href=\"https://www.gousto.co.uk/jobs\">benefits</a>!&#xa0;</strong></p><p><strong>Equal Opportunities&#xa0;</strong></p><p>Whether it is creating diversity in our recipes or building new teams, we care about our people and the opportunities they have at Gousto.&#xa0;</p><p>We are committed to equality of opportunity across our organisation. At all levels we promote equality, ensuring our people are consistently treated in a fair and equal manner.&#xa0;</p><p>If you need reasonable adjustments at any point in the application or interview process, please let us know.</p><p>In your application, please feel free to note which pronouns you use (For example - she/her/hers, he/him/his, they/them/theirs, etc).</p><p>If you like what you’ve read about Gousto and want to find out more please click I’m interested below to apply!&#xa0;</p><p>&#xa0;</p><p>#LI-Hybrid</p>"}}},"active":true,"visibility":"PUBLIC","industry":{"id":"food_and_beverages","label":"Food And Beverages"},"function":{"id":"information_technology","label":"Information Technology"},"experienceLevel":{"id":"associate","label":"Associate"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"language":{"code":"en","label":"English","labelNative":"English (US)"}}
-  recorded_at: Mon, 29 Jul 2024 09:10:05 GMT
+        {"id":"744000003360384","name":"Junior Technical Artworker - (12 Month Fixed Term Contract)","uuid":"d67d464f-923c-4e6c-8a94-55113df4dd68","jobId":"30508f5b-8f17-4de1-8395-8f616af41d69","jobAdId":"862af3c0-0fd6-4041-8bd7-5e1c1a3c8e1b","defaultJobAd":true,"refNumber":"000000000574","company":{"name":"Gousto","identifier":"Gousto1"},"location":{"city":"London","country":"gb","remote":false},"customField":[{"fieldId":"630c7100443cdf3e99c72afa","fieldLabel":"Grade","valueId":"1520c772-c2db-4295-97f5-cd489facac05","valueLabel":"No Grade"},{"fieldId":"630f84820e23e120dc6765d9","fieldLabel":"Legal entity","valueId":"fb5748db-69db-483b-b9c3-06f38d9296db","valueLabel":"Gousto"},{"fieldId":"630c74d55d9cbe1185a98b8f","fieldLabel":"Pay frequency","valueId":"7cade280-1285-48d0-a136-ea0e0d038243","valueLabel":"Monthly"},{"fieldId":"630c743b160583356526ff22","fieldLabel":"Tribe","valueId":"0e447d0a-2ee5-4f18-8154-07908e50a8d3","valueLabel":"Choice"},{"fieldId":"63a2ed58cccaf22c88b3909d","fieldLabel":"Domain/Skills","valueId":"bc3b4b69-4858-4ccd-88a3-d99ddafc17e9","valueLabel":"Default"},{"fieldId":"630c7063d147dd2caf234895","fieldLabel":"Division","valueId":"f1225bfe-265b-422d-8408-a8d3500d2fac","valueLabel":"Food Technical"},{"fieldId":"630f42baa093972a1e31f0ac","fieldLabel":"Planful Hiring Manager","valueLabel":"Sarah Fancourt"},{"fieldId":"630c718549d137263821dbba","fieldLabel":"Cost centre","valueId":"453d3290-2ab5-455e-814a-47fac3037fb7","valueLabel":"C5400"},{"fieldId":"630c751c775db95e9f403d17","fieldLabel":"Employee Type","valueId":"FTC","valueLabel":"FTC - Full Time"},{"fieldId":"632a2fbb5f1d045b5e572594","fieldLabel":"Confidential Job","valueId":"aeb77cba-230a-4b9d-a31f-88672f23503e","valueLabel":"No"},{"fieldId":"COUNTRY","fieldLabel":"Country","valueId":"gb","valueLabel":"United Kingdom"},{"fieldId":"6311e8352f4ccc2569c5df15","fieldLabel":"Contracted hours","valueLabel":"0"},{"fieldId":"6315bbb61806394796f5b97a","fieldLabel":"Maximum Annual Salary","valueLabel":"26000 GBP"},{"fieldId":"630c7488443cdf3e99c72afb","fieldLabel":"Squad","valueId":"5a7e8125-914f-4c69-875e-544e2592cadf","valueLabel":"Default"},{"fieldId":"638dc74c67724579b30f4968","fieldLabel":"Career track","valueId":"6087cc0d-9d78-40a0-b5ba-94fa2e397c0b","valueLabel":"Default"},{"fieldId":"62fa018542f61523460b010e","fieldLabel":"Brands","valueId":"default","valueLabel":"Gousto"}],"releasedDate":"2024-07-29T10:18:30.916Z","creator":{"name":"","avatarUrl":""},"postingUrl":"https://jobs.smartrecruiters.com/Gousto1/744000003360384-junior-technical-artworker-12-month-fixed-term-contract-","applyUrl":"https://jobs.smartrecruiters.com/Gousto1/744000003360384-junior-technical-artworker-12-month-fixed-term-contract-?oga=true","referralUrl":"https://jobs.smartrecruiters.com/external-referrals/company/Gousto1/publication/d67d464f-923c-4e6c-8a94-55113df4dd68?dcr_ci=Gousto1","jobAd":{"sections":{"companyDescription":{"title":"Company Description","text":"<p>Here at Gousto, we are on a mission to become the UK's most loved way to eat dinner, and for every meal to leave the planet better off. Gousto is changing how people shop, cook and eat food at home. It’s an incredibly exciting time to join our team - and we’re a friendly bunch!</p><p>We’re proud to be one of the fastest-growing companies in the UK. Powered by data and a love of food, we’re a recipe box company that’s disrupting the sector, and we’re passionate about our diverse team and our customers.</p><p>All of our people are responsible for the success of Gousto, and we’re passionate about creating an inclusive environment for all to thrive. Our guiding values - Dream, Deliver and Care - show our commitment to innovation, our ambition to hit goals at speed, and our deep respect for the people we work with.</p>"},"jobDescription":{"title":"Job Description","text":"<p><strong>Core Responsibilities:</strong></p><p><strong>Recipe Card Creation</strong></p><ul><li>Producing recipe cards, using the master templates designed by our Creative team, in line with our menu on a weekly basis</li><li>Carrying out amends to the recipe cards before the weekly print deadline</li><li>Working within a cross-functional team to bring both copy and design work together</li><li>Working with the Photography team to provide recipe style guides for outsourced photographers</li><li>Continuous development and honing of the technical abilities relevant to the role, delivering the highest standard of execution</li><li>Constantly seeking and implementing requested improvements</li><li>Proofing and checking print ready artwork</li><li>Supporting creative changes by making amends to templates, in line with Brand guidelines</li><li>Creating digital versions of our recipe cards for the Customer Care team</li></ul><p><strong>Digital Asset Management</strong></p><ul><li>Managing our large database of imagery</li><li>Resizing of images for respective assets</li><li>Adhoc Photoshopping/retouching of images, to support last minute ingredient changes on our imagery</li><li>Uploading images to the Gousto internal system within strict timelines</li><li>Offer Artworking support to wider teams, including tech to drive tooling initiatives</li><li>Ownership of ‘project’ work streams i.e. driving efficiencies, improving processes and developing specialisms</li><li>Get stuck in with our personal development opportunities! PDPs, lots of opportunities to learn about the wider business, and our mentorship programme&#xa0;</li></ul><p><strong>Who you are/experience required:</strong></p><ul><li>Experienced with the Adobe Creative Suite (specifically Adobe Indesign and Photoshop)</li><li>You have a meticulous eye for detail and a mind for logical structure</li><li>Ability to work to a weekly schedule</li><li>You take responsibility for managing the standard and quality of your own output</li><li>Proven ability to work to short deadlines and fast turnaround times on a number of projects at any given time</li><li>Strong organisational skills</li><li>Excellent communication skills</li><li>Good time management skills</li><li>High level of written and spoken English</li></ul><p><strong>Nice to haves:</strong></p><ul><li>Experience of working within an artworking role</li><li>Knowledge of the print production process and creating print ready artwork</li><li>Experience working with prebuilt master templates and are confident with Data Merge</li><li>Writing/amending InDesign scripts to further increase the automation of the recipe card creation process</li><li>A passion for food!</li></ul>"},"qualifications":{"title":"Qualifications","text":""},"additionalInformation":{"title":"Additional Information","text":"<p><strong>Benefits</strong></p><p>Click here to see our company<strong> <a href=\"https://www.gousto.co.uk/jobs\">benefits</a>!&#xa0;</strong></p><p><strong>Equal Opportunities&#xa0;</strong></p><p>Whether it is creating diversity in our recipes or building new teams, we care about our people and the opportunities they have at Gousto.&#xa0;</p><p>We are committed to equality of opportunity across our organisation. At all levels we promote equality, ensuring our people are consistently treated in a fair and equal manner.&#xa0;</p><p>If you need reasonable adjustments at any point in the application or interview process, please let us know.</p><p>In your application, please feel free to note which pronouns you use (For example - she/her/hers, he/him/his, they/them/theirs, etc).</p><p>If you like what you’ve read about Gousto and want to find out more please click I’m interested below to apply!&#xa0;</p><p>#LI-Hybrid</p>"}}},"active":true,"visibility":"PUBLIC","industry":{"id":"food_and_beverages","label":"Food And Beverages"},"function":{"id":"information_technology","label":"Information Technology"},"experienceLevel":{"id":"associate","label":"Associate"},"typeOfEmployment":{"id":"permanent","label":"Full-time"},"language":{"code":"en","label":"English","labelNative":"English (US)"}}
+  recorded_at: Tue, 30 Jul 2024 16:28:56 GMT
 - request:
     method: get
-    uri: http://dev.virtualearth.net/REST/v1/Locations/Warrington,%20United%20Kingdom?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
+    uri: http://dev.virtualearth.net/REST/v1/Locations/London,%20United%20Kingdom?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
     body:
       encoding: US-ASCII
       string: ''
@@ -717,11 +599,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:10:06 GMT
+      - Tue, 30 Jul 2024 16:28:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
-      - '2464'
+      - '2436'
       Connection:
       - keep-alive
       Access-Control-Allow-Headers:
@@ -735,18 +617,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 7e9253133b43422e8d7d0f7b0b2d6b9b
+      - f5cff170ea7c5ec1ea30be14975b722d
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75c6e27ab4426a50fc197c4235293|Ref A: 69328B4FC8C64A33803ECC98F7E6CA3A
-        Ref B: LON212050706027 Ref C: 2024-07-29T09:10:05Z'
+      - 'Ref SnR: 66a914c8bed74ca19a60024929f19366|Ref A: 015C59C48D864D5CA9B9AAE7066A659F
+        Ref B: DB3EDGE3218 Ref C: 2024-07-30T16:28:56Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-zk7ph, mapsplatform-forwardgeocoder-service-69c675d4f5-65llh
+      - mapsplatform-frontend-5989d449fd-7xwbn, mapsplatform-forwardgeocoder-service-69c675d4f5-lstqp
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '98'
+      - '74'
       X-Azure-Ref:
-      - 20240729T091006Z-154b59dbc6d5bjzw8f9f4spwa800000007xg00000000w0u1
+      - 20240730T162856Z-154b59dbc6dsrvwcuf0s6c73vg000000087g00000001dda3
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -754,11 +636,11 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:10:06 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:56 GMT
 - request:
     method: get
-    uri: http://dev.virtualearth.net/REST/v1/Locations/Warrington?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
+    uri: http://dev.virtualearth.net/REST/v1/Locations/London?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
     body:
       encoding: US-ASCII
       string: ''
@@ -775,11 +657,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:10:06 GMT
+      - Tue, 30 Jul 2024 16:28:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
-      - '3684'
+      - '3612'
       Connection:
       - keep-alive
       Access-Control-Allow-Headers:
@@ -793,18 +675,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 0aea8fdc916da6bd51a60bdd533256da
+      - ff514ce6e809e3c86a42060e97eec14d
       X-Msedge-Ref:
-      - 'Ref A: 68582049FDA7445E99AD4985E089CA41 Ref B: DB3EDGE1812 Ref C: 2024-07-29T09:10:06Z|Ref
-        SnR: 66a75c6ebc1443b8ad56007d5bc5bf7a'
+      - 'Ref SnR: 66a914c8fc004177a67530940088042a|Ref A: B7007EA310DA47A582A2EABDE93F4B71
+        Ref B: DB3EDGE2819 Ref C: 2024-07-30T16:28:56Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-s5s9v, mapsplatform-forwardgeocoder-service-69c675d4f5-7z7j7
+      - mapsplatform-frontend-5989d449fd-57vjn, mapsplatform-forwardgeocoder-service-69c675d4f5-wq4qq
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '71'
+      - '65'
       X-Azure-Ref:
-      - 20240729T091006Z-17cc7bff7582qdhsbqusbvaca0000000031000000000e14k
+      - 20240730T162856Z-154b59dbc6d5lqv7gb5ha8t1mw00000005kg00000001f23e
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -812,8 +694,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:10:06 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:56 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/United%20Kingdom?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -833,7 +715,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:10:06 GMT
+      - Tue, 30 Jul 2024 16:28:56 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -851,18 +733,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - d29b07f89e560be0a480aeb75ed649f3
+      - e896f7e58366941e6b30b62d0e06a92a
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75c6e5e0a413f9b77b59f0134e9e0|Ref A: 0DBDDE62D04E4A1380BCAE5392A84B1B
-        Ref B: DB3EDGE2912 Ref C: 2024-07-29T09:10:06Z'
+      - 'Ref SnR: 66a914c803b343dc9620a87bd1cb3a5f|Ref A: 2110D2F6E1DD42BE8C92CB38DD7F9C0D
+        Ref B: DB3EDGE2909 Ref C: 2024-07-30T16:28:56Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-n9sn9, mapsplatform-forwardgeocoder-service-69c675d4f5-ltvqp
+      - mapsplatform-frontend-5989d449fd-79dtw, mapsplatform-forwardgeocoder-service-69c675d4f5-6d962
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '204'
+      - '79'
       X-Azure-Ref:
-      - 20240729T091006Z-154b59dbc6d4k5kgvkz7d1080800000009cg0000000096zr
+      - 20240730T162856Z-154b59dbc6dg5gt9rt4g8rzcmn00000007rg00000000ta63
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -870,6 +752,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:10:06 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:28:56 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_workable.yml b/spec/fixtures/cassettes/create_job_workable.yml
index 75e7671a..f16f9cc4 100644
--- a/spec/fixtures/cassettes/create_job_workable.yml
+++ b/spec/fixtures/cassettes/create_job_workable.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:34 GMT
+      - Tue, 30 Jul 2024 16:26:32 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -31,11 +31,11 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Set-Cookie:
-      - __cf_bm=MbplsAqqoY1XsD1cV8oUtBxXK1tZ4A0gU0o5.bJFHZ0-1722244474-1.0.1.1-57DeYRRDL1v1VMkJ2a0.oe4Y24kREDliJimGwUJPG1CN6XXhYoaDBZkvBggpxN_LqzkYsLBZ3LnxtYrqnqHf4Q;
-        path=/; expires=Mon, 29-Jul-24 09:44:34 GMT; domain=.workable.com; HttpOnly;
+      - __cf_bm=sFNwBwlEsX2kibSJdmFKz.jVVfu00lozraWTi4K4TQM-1722356792-1.0.1.1-Vwpw7POUNhX4bx..E6pTjNEK7Xq66fuTa7Owd6j6FRqcf7ss4It7khCi.36cg_7uTx3vFmlHbh2.mALtkCxiMg;
+        path=/; expires=Tue, 30-Jul-24 16:56:32 GMT; domain=.workable.com; HttpOnly;
         Secure; SameSite=None
-      - wmc=%7B%22cookie_id%22%3A%22265bfd23-ae2c-4007-a3e0-6483f904fd55%22%7D; path=/;
-        expires=Sat, 29 Jul 2034 21:14:34 GMT; domain=.workable.com; samesite=none;
+      - wmc=%7B%22cookie_id%22%3A%22749d6674-7ca9-4d37-a819-33bd3be9c450%22%7D; path=/;
+        expires=Mon, 31 Jul 2034 04:26:32 GMT; domain=.workable.com; samesite=none;
         secure
       Expect-Ct:
       - enforce, max-age=86400
@@ -45,8 +45,8 @@ http_interactions:
       - nosniff
       X-Xss-Protection:
       - 1; mode=block
-      X-Cached-Response:
-      - HIT
+      Content-Disposition:
+      - inline; filename=results.json
       X-Sv:
       - 937c2fd34e9bf1ab26776b33cf81a156e89b3989dc216f286d21567de7ac4f2c
       Cf-Cache-Status:
@@ -56,16 +56,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabffde0de46389
+      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b5fdfbc3369a
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabffde0de46389-LHR
+      - 8ab6b5fdfbc3369a-LHR
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         {"name":"Southern National Roofing","description":"<p>Southern National Roofing is a professional roofing contractor that focuses on energy-efficient residential roofing replacement, using products and installation methods geared to the unique climate and building challenges in the southeastern United States. We are certified to install most roofing brands including products from GAF, the manufacturer of North America’s #1-selling Timberline® roofing shingles.</p>","jobs":[{"title":"Appointment Setter","shortcode":"7659BE0024","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7659BE0024","shortlink":"https://apply.workable.com/j/7659BE0024","application_url":"https://apply.workable.com/j/7659BE0024/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our WILMINGTON, DE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"E07D9D1957","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E07D9D1957","shortlink":"https://apply.workable.com/j/E07D9D1957","application_url":"https://apply.workable.com/j/E07D9D1957/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our WILMINGTON, DE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"AB7BE627E1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AB7BE627E1","shortlink":"https://apply.workable.com/j/AB7BE627E1","application_url":"https://apply.workable.com/j/AB7BE627E1/apply","published_on":"2023-10-02","created_at":"2023-10-02","country":"United States","city":"Charleston","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charleston","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLESTON, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"41BBB2DBE8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/41BBB2DBE8","shortlink":"https://apply.workable.com/j/41BBB2DBE8","application_url":"https://apply.workable.com/j/41BBB2DBE8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"8DDDAAAA55","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8DDDAAAA55","shortlink":"https://apply.workable.com/j/8DDDAAAA55","application_url":"https://apply.workable.com/j/8DDDAAAA55/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"2248DDE46A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2248DDE46A","shortlink":"https://apply.workable.com/j/2248DDE46A","application_url":"https://apply.workable.com/j/2248DDE46A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"FC1DD2FEAF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/FC1DD2FEAF","shortlink":"https://apply.workable.com/j/FC1DD2FEAF","application_url":"https://apply.workable.com/j/FC1DD2FEAF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"11F35D391A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/11F35D391A","shortlink":"https://apply.workable.com/j/11F35D391A","application_url":"https://apply.workable.com/j/11F35D391A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"1C3EC2297A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1C3EC2297A","shortlink":"https://apply.workable.com/j/1C3EC2297A","application_url":"https://apply.workable.com/j/1C3EC2297A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"F207EEB77B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F207EEB77B","shortlink":"https://apply.workable.com/j/F207EEB77B","application_url":"https://apply.workable.com/j/F207EEB77B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A62C7FFB5A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A62C7FFB5A","shortlink":"https://apply.workable.com/j/A62C7FFB5A","application_url":"https://apply.workable.com/j/A62C7FFB5A/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"25A426104D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/25A426104D","shortlink":"https://apply.workable.com/j/25A426104D","application_url":"https://apply.workable.com/j/25A426104D/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"581F2DF689","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/581F2DF689","shortlink":"https://apply.workable.com/j/581F2DF689","application_url":"https://apply.workable.com/j/581F2DF689/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"944FEC96C0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/944FEC96C0","shortlink":"https://apply.workable.com/j/944FEC96C0","application_url":"https://apply.workable.com/j/944FEC96C0/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"8A4756A19F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8A4756A19F","shortlink":"https://apply.workable.com/j/8A4756A19F","application_url":"https://apply.workable.com/j/8A4756A19F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Annapolis","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Annapolis","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"2A241C2A74","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2A241C2A74","shortlink":"https://apply.workable.com/j/2A241C2A74","application_url":"https://apply.workable.com/j/2A241C2A74/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"E43D5A9F14","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E43D5A9F14","shortlink":"https://apply.workable.com/j/E43D5A9F14","application_url":"https://apply.workable.com/j/E43D5A9F14/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"4D05F16C78","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4D05F16C78","shortlink":"https://apply.workable.com/j/4D05F16C78","application_url":"https://apply.workable.com/j/4D05F16C78/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"0C9781DB0B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0C9781DB0B","shortlink":"https://apply.workable.com/j/0C9781DB0B","application_url":"https://apply.workable.com/j/0C9781DB0B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"15258E3B5B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/15258E3B5B","shortlink":"https://apply.workable.com/j/15258E3B5B","application_url":"https://apply.workable.com/j/15258E3B5B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"17FAD80C09","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/17FAD80C09","shortlink":"https://apply.workable.com/j/17FAD80C09","application_url":"https://apply.workable.com/j/17FAD80C09/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"0A0F60C4F2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0A0F60C4F2","shortlink":"https://apply.workable.com/j/0A0F60C4F2","application_url":"https://apply.workable.com/j/0A0F60C4F2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"3E59F76FAC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3E59F76FAC","shortlink":"https://apply.workable.com/j/3E59F76FAC","application_url":"https://apply.workable.com/j/3E59F76FAC/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"C7735D4CB9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C7735D4CB9","shortlink":"https://apply.workable.com/j/C7735D4CB9","application_url":"https://apply.workable.com/j/C7735D4CB9/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A8CCE563D7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A8CCE563D7","shortlink":"https://apply.workable.com/j/A8CCE563D7","application_url":"https://apply.workable.com/j/A8CCE563D7/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"1A1E53B755","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1A1E53B755","shortlink":"https://apply.workable.com/j/1A1E53B755","application_url":"https://apply.workable.com/j/1A1E53B755/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A32A8A4288","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A32A8A4288","shortlink":"https://apply.workable.com/j/A32A8A4288","application_url":"https://apply.workable.com/j/A32A8A4288/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"62A962AFFF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/62A962AFFF","shortlink":"https://apply.workable.com/j/62A962AFFF","application_url":"https://apply.workable.com/j/62A962AFFF/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"4690BDDD33","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4690BDDD33","shortlink":"https://apply.workable.com/j/4690BDDD33","application_url":"https://apply.workable.com/j/4690BDDD33/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"DB9371FBC2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DB9371FBC2","shortlink":"https://apply.workable.com/j/DB9371FBC2","application_url":"https://apply.workable.com/j/DB9371FBC2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"CADC40FD39","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CADC40FD39","shortlink":"https://apply.workable.com/j/CADC40FD39","application_url":"https://apply.workable.com/j/CADC40FD39/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"8708710B12","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8708710B12","shortlink":"https://apply.workable.com/j/8708710B12","application_url":"https://apply.workable.com/j/8708710B12/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Exciting Opportunity for Young Marketing Enthusiasts!</p><p>Are you a young marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2E4E713D75","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2E4E713D75","shortlink":"https://apply.workable.com/j/2E4E713D75","application_url":"https://apply.workable.com/j/2E4E713D75/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity for Young Marketing Enthusiasts!</p><p>Are you a young marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A02BA6B18F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A02BA6B18F","shortlink":"https://apply.workable.com/j/A02BA6B18F","application_url":"https://apply.workable.com/j/A02BA6B18F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"66B9765E1F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/66B9765E1F","shortlink":"https://apply.workable.com/j/66B9765E1F","application_url":"https://apply.workable.com/j/66B9765E1F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"C6ED49CCC5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C6ED49CCC5","shortlink":"https://apply.workable.com/j/C6ED49CCC5","application_url":"https://apply.workable.com/j/C6ED49CCC5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"33D771BD6F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/33D771BD6F","shortlink":"https://apply.workable.com/j/33D771BD6F","application_url":"https://apply.workable.com/j/33D771BD6F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A7ECEBBA42","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A7ECEBBA42","shortlink":"https://apply.workable.com/j/A7ECEBBA42","application_url":"https://apply.workable.com/j/A7ECEBBA42/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"9B3E0AE0F7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9B3E0AE0F7","shortlink":"https://apply.workable.com/j/9B3E0AE0F7","application_url":"https://apply.workable.com/j/9B3E0AE0F7/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"64D4F974C2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/64D4F974C2","shortlink":"https://apply.workable.com/j/64D4F974C2","application_url":"https://apply.workable.com/j/64D4F974C2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2DD07239C2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2DD07239C2","shortlink":"https://apply.workable.com/j/2DD07239C2","application_url":"https://apply.workable.com/j/2DD07239C2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"3E5C44463A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3E5C44463A","shortlink":"https://apply.workable.com/j/3E5C44463A","application_url":"https://apply.workable.com/j/3E5C44463A/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"EB4BD2DF9C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EB4BD2DF9C","shortlink":"https://apply.workable.com/j/EB4BD2DF9C","application_url":"https://apply.workable.com/j/EB4BD2DF9C/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"093D7AD59F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/093D7AD59F","shortlink":"https://apply.workable.com/j/093D7AD59F","application_url":"https://apply.workable.com/j/093D7AD59F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2176505A35","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2176505A35","shortlink":"https://apply.workable.com/j/2176505A35","application_url":"https://apply.workable.com/j/2176505A35/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"7F5AF2FD27","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7F5AF2FD27","shortlink":"https://apply.workable.com/j/7F5AF2FD27","application_url":"https://apply.workable.com/j/7F5AF2FD27/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"131A4B882F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/131A4B882F","shortlink":"https://apply.workable.com/j/131A4B882F","application_url":"https://apply.workable.com/j/131A4B882F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"69E00CB8BA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/69E00CB8BA","shortlink":"https://apply.workable.com/j/69E00CB8BA","application_url":"https://apply.workable.com/j/69E00CB8BA/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"927846AF02","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/927846AF02","shortlink":"https://apply.workable.com/j/927846AF02","application_url":"https://apply.workable.com/j/927846AF02/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"E4FF1BBBC9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E4FF1BBBC9","shortlink":"https://apply.workable.com/j/E4FF1BBBC9","application_url":"https://apply.workable.com/j/E4FF1BBBC9/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"4FD957F151","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4FD957F151","shortlink":"https://apply.workable.com/j/4FD957F151","application_url":"https://apply.workable.com/j/4FD957F151/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"4E224B9A7C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4E224B9A7C","shortlink":"https://apply.workable.com/j/4E224B9A7C","application_url":"https://apply.workable.com/j/4E224B9A7C/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"53BE062C2B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/53BE062C2B","shortlink":"https://apply.workable.com/j/53BE062C2B","application_url":"https://apply.workable.com/j/53BE062C2B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"0723474365","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0723474365","shortlink":"https://apply.workable.com/j/0723474365","application_url":"https://apply.workable.com/j/0723474365/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A5519A4680","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A5519A4680","shortlink":"https://apply.workable.com/j/A5519A4680","application_url":"https://apply.workable.com/j/A5519A4680/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"622803D6DD","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/622803D6DD","shortlink":"https://apply.workable.com/j/622803D6DD","application_url":"https://apply.workable.com/j/622803D6DD/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Recruiter","shortcode":"11625446FB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Recruiting","url":"https://apply.workable.com/j/11625446FB","shortlink":"https://apply.workable.com/j/11625446FB","application_url":"https://apply.workable.com/j/11625446FB/apply","published_on":"2024-02-23","created_at":"2024-02-23","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Human Resources","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Join Our Team as an Entry Level Recruiter!</p><p>Southern National Roofing is a rapidly growing roofing and home improvement company, and we're seeking motivated individuals to join our HR department as entry-level recruiters. As an entry-level recruiter, you'll play a crucial role in attracting and selecting top talent that aligns with our company's values and goals.</p><p>Why Join Us?</p><p>At Southern National Roofing, we value our employees and their professional growth. As an entry-level recruiter, you'll have the opportunity to learn and grow in a supportive and collaborative environment. We provide comprehensive training and development programs, ensuring that you have the necessary skills and knowledge to excel in your role. Join our team and be part of an exciting journey as we continue to expand and make a difference in the lives of homeowners through our high-quality roofing solutions.</p><p>Key Responsibilities:</p><ul> <li>Assist with sourcing, screening, and selecting candidates for open positions</li> <li>Conduct phone and in-person interviews to assess candidate qualifications</li> <li>Coordinate and schedule interviews with hiring managers</li> <li>Manage the applicant tracking system and maintain accurate candidate records</li> <li>Assist with onboarding new hires and conducting orientation sessions</li> </ul><p></p><p>This position requires daily attendance in our Charlotte, NC office.</p><p><strong>Requirements</strong></p><ul> <li>High school diploma or equivalent</li> <li>Strong communication and interpersonal skills</li> <li>Ability to work with a sense of urgency and meet deadlines</li> <li>Attention to detail and strong organizational skills</li> <li>Proficiency in Microsoft Office Suite</li> <li>Ability to maintain confidentiality and handle sensitive information</li> <li>Prior experience in recruitment or HR is a plus, but not required</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $50,000+ (Base Salary + Commission + Bonuses)</li> <li>Medical and Mental Health Benefits</li> <li>Paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"A5599863A0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A5599863A0","shortlink":"https://apply.workable.com/j/A5599863A0","application_url":"https://apply.workable.com/j/A5599863A0/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"B705ED5163","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B705ED5163","shortlink":"https://apply.workable.com/j/B705ED5163","application_url":"https://apply.workable.com/j/B705ED5163/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"53E26D14D3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/53E26D14D3","shortlink":"https://apply.workable.com/j/53E26D14D3","application_url":"https://apply.workable.com/j/53E26D14D3/apply","published_on":"2024-04-29","created_at":"2024-04-29","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"85C117F6B3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/85C117F6B3","shortlink":"https://apply.workable.com/j/85C117F6B3","application_url":"https://apply.workable.com/j/85C117F6B3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"13CFEF8FF3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/13CFEF8FF3","shortlink":"https://apply.workable.com/j/13CFEF8FF3","application_url":"https://apply.workable.com/j/13CFEF8FF3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"8928451BA2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8928451BA2","shortlink":"https://apply.workable.com/j/8928451BA2","application_url":"https://apply.workable.com/j/8928451BA2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"E1585E246E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E1585E246E","shortlink":"https://apply.workable.com/j/E1585E246E","application_url":"https://apply.workable.com/j/E1585E246E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"083A5D36C9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/083A5D36C9","shortlink":"https://apply.workable.com/j/083A5D36C9","application_url":"https://apply.workable.com/j/083A5D36C9/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Monroe","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Monroe","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"13D9050FD4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/13D9050FD4","shortlink":"https://apply.workable.com/j/13D9050FD4","application_url":"https://apply.workable.com/j/13D9050FD4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lexington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lexington","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"B551BB4828","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B551BB4828","shortlink":"https://apply.workable.com/j/B551BB4828","application_url":"https://apply.workable.com/j/B551BB4828/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"CD35F1E9F8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CD35F1E9F8","shortlink":"https://apply.workable.com/j/CD35F1E9F8","application_url":"https://apply.workable.com/j/CD35F1E9F8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"4E3244D221","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4E3244D221","shortlink":"https://apply.workable.com/j/4E3244D221","application_url":"https://apply.workable.com/j/4E3244D221/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"0432F47723","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0432F47723","shortlink":"https://apply.workable.com/j/0432F47723","application_url":"https://apply.workable.com/j/0432F47723/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"5542FD5BBF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5542FD5BBF","shortlink":"https://apply.workable.com/j/5542FD5BBF","application_url":"https://apply.workable.com/j/5542FD5BBF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"DB7FEDE601","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DB7FEDE601","shortlink":"https://apply.workable.com/j/DB7FEDE601","application_url":"https://apply.workable.com/j/DB7FEDE601/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"334D7BBB28","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/334D7BBB28","shortlink":"https://apply.workable.com/j/334D7BBB28","application_url":"https://apply.workable.com/j/334D7BBB28/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"EF0C15C19D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EF0C15C19D","shortlink":"https://apply.workable.com/j/EF0C15C19D","application_url":"https://apply.workable.com/j/EF0C15C19D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"4759A849E8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4759A849E8","shortlink":"https://apply.workable.com/j/4759A849E8","application_url":"https://apply.workable.com/j/4759A849E8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Asheboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Asheboro","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"319D2CDFAF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/319D2CDFAF","shortlink":"https://apply.workable.com/j/319D2CDFAF","application_url":"https://apply.workable.com/j/319D2CDFAF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"19499025B5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/19499025B5","shortlink":"https://apply.workable.com/j/19499025B5","application_url":"https://apply.workable.com/j/19499025B5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"C9588F86D4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C9588F86D4","shortlink":"https://apply.workable.com/j/C9588F86D4","application_url":"https://apply.workable.com/j/C9588F86D4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"FD12F1A3AB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/FD12F1A3AB","shortlink":"https://apply.workable.com/j/FD12F1A3AB","application_url":"https://apply.workable.com/j/FD12F1A3AB/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"2356649AF4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2356649AF4","shortlink":"https://apply.workable.com/j/2356649AF4","application_url":"https://apply.workable.com/j/2356649AF4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F72156267A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F72156267A","shortlink":"https://apply.workable.com/j/F72156267A","application_url":"https://apply.workable.com/j/F72156267A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"CD45C95CB3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CD45C95CB3","shortlink":"https://apply.workable.com/j/CD45C95CB3","application_url":"https://apply.workable.com/j/CD45C95CB3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Fayetteville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Fayetteville","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"75560CA15F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/75560CA15F","shortlink":"https://apply.workable.com/j/75560CA15F","application_url":"https://apply.workable.com/j/75560CA15F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"3BBED68423","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3BBED68423","shortlink":"https://apply.workable.com/j/3BBED68423","application_url":"https://apply.workable.com/j/3BBED68423/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F0D77C7277","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F0D77C7277","shortlink":"https://apply.workable.com/j/F0D77C7277","application_url":"https://apply.workable.com/j/F0D77C7277/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rocky Mount","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rocky Mount","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"7277358208","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7277358208","shortlink":"https://apply.workable.com/j/7277358208","application_url":"https://apply.workable.com/j/7277358208/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"E124EBD0D0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E124EBD0D0","shortlink":"https://apply.workable.com/j/E124EBD0D0","application_url":"https://apply.workable.com/j/E124EBD0D0/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"40F78FA40D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/40F78FA40D","shortlink":"https://apply.workable.com/j/40F78FA40D","application_url":"https://apply.workable.com/j/40F78FA40D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"32BA38FC76","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/32BA38FC76","shortlink":"https://apply.workable.com/j/32BA38FC76","application_url":"https://apply.workable.com/j/32BA38FC76/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"0CA3CDBE73","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CA3CDBE73","shortlink":"https://apply.workable.com/j/0CA3CDBE73","application_url":"https://apply.workable.com/j/0CA3CDBE73/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F14C3BCA12","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F14C3BCA12","shortlink":"https://apply.workable.com/j/F14C3BCA12","application_url":"https://apply.workable.com/j/F14C3BCA12/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Exciting Opportunity for Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"C8BDCF23EC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C8BDCF23EC","shortlink":"https://apply.workable.com/j/C8BDCF23EC","application_url":"https://apply.workable.com/j/C8BDCF23EC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Annapolis","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Annapolis","region":"Maryland","hidden":false}],"description":"<p>Exciting Opportunity for Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"9409C009FB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9409C009FB","shortlink":"https://apply.workable.com/j/9409C009FB","application_url":"https://apply.workable.com/j/9409C009FB/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our WILMINGTON, DE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"66293E1204","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/66293E1204","shortlink":"https://apply.workable.com/j/66293E1204","application_url":"https://apply.workable.com/j/66293E1204/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our WILMINGTON, DE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"DEE35D30B2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DEE35D30B2","shortlink":"https://apply.workable.com/j/DEE35D30B2","application_url":"https://apply.workable.com/j/DEE35D30B2/apply","published_on":"2023-10-02","created_at":"2023-10-02","country":"United States","city":"Charleston","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charleston","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLESTON, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"E809CE5D55","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E809CE5D55","shortlink":"https://apply.workable.com/j/E809CE5D55","application_url":"https://apply.workable.com/j/E809CE5D55/apply","published_on":"2024-04-29","created_at":"2024-04-29","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"E0DEBD413D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E0DEBD413D","shortlink":"https://apply.workable.com/j/E0DEBD413D","application_url":"https://apply.workable.com/j/E0DEBD413D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"B261D407BA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B261D407BA","shortlink":"https://apply.workable.com/j/B261D407BA","application_url":"https://apply.workable.com/j/B261D407BA/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"8AA84868AC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8AA84868AC","shortlink":"https://apply.workable.com/j/8AA84868AC","application_url":"https://apply.workable.com/j/8AA84868AC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"9A07DD44FE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9A07DD44FE","shortlink":"https://apply.workable.com/j/9A07DD44FE","application_url":"https://apply.workable.com/j/9A07DD44FE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"E19BC1CB78","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E19BC1CB78","shortlink":"https://apply.workable.com/j/E19BC1CB78","application_url":"https://apply.workable.com/j/E19BC1CB78/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"481407118D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/481407118D","shortlink":"https://apply.workable.com/j/481407118D","application_url":"https://apply.workable.com/j/481407118D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"7295A4BA2D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7295A4BA2D","shortlink":"https://apply.workable.com/j/7295A4BA2D","application_url":"https://apply.workable.com/j/7295A4BA2D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"D8188C6C23","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/D8188C6C23","shortlink":"https://apply.workable.com/j/D8188C6C23","application_url":"https://apply.workable.com/j/D8188C6C23/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Asheboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Asheboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"0AE9D9A4B8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0AE9D9A4B8","shortlink":"https://apply.workable.com/j/0AE9D9A4B8","application_url":"https://apply.workable.com/j/0AE9D9A4B8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"5516AF1435","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5516AF1435","shortlink":"https://apply.workable.com/j/5516AF1435","application_url":"https://apply.workable.com/j/5516AF1435/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"37059C3D81","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/37059C3D81","shortlink":"https://apply.workable.com/j/37059C3D81","application_url":"https://apply.workable.com/j/37059C3D81/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"39C4C003AD","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/39C4C003AD","shortlink":"https://apply.workable.com/j/39C4C003AD","application_url":"https://apply.workable.com/j/39C4C003AD/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"5177EA7BFE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5177EA7BFE","shortlink":"https://apply.workable.com/j/5177EA7BFE","application_url":"https://apply.workable.com/j/5177EA7BFE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"3EF298D914","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3EF298D914","shortlink":"https://apply.workable.com/j/3EF298D914","application_url":"https://apply.workable.com/j/3EF298D914/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"8BA7416F08","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8BA7416F08","shortlink":"https://apply.workable.com/j/8BA7416F08","application_url":"https://apply.workable.com/j/8BA7416F08/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"ED10F5174B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/ED10F5174B","shortlink":"https://apply.workable.com/j/ED10F5174B","application_url":"https://apply.workable.com/j/ED10F5174B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"E6DCEFBE2C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E6DCEFBE2C","shortlink":"https://apply.workable.com/j/E6DCEFBE2C","application_url":"https://apply.workable.com/j/E6DCEFBE2C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Monroe","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Monroe","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"220FAFDAF0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/220FAFDAF0","shortlink":"https://apply.workable.com/j/220FAFDAF0","application_url":"https://apply.workable.com/j/220FAFDAF0/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lexington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lexington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"2BA90B9A36","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2BA90B9A36","shortlink":"https://apply.workable.com/j/2BA90B9A36","application_url":"https://apply.workable.com/j/2BA90B9A36/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"CEE1C2005A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CEE1C2005A","shortlink":"https://apply.workable.com/j/CEE1C2005A","application_url":"https://apply.workable.com/j/CEE1C2005A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"AFC93BC188","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AFC93BC188","shortlink":"https://apply.workable.com/j/AFC93BC188","application_url":"https://apply.workable.com/j/AFC93BC188/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"6DF7A90EC1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/6DF7A90EC1","shortlink":"https://apply.workable.com/j/6DF7A90EC1","application_url":"https://apply.workable.com/j/6DF7A90EC1/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Fayetteville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Fayetteville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0CDA1B270B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CDA1B270B","shortlink":"https://apply.workable.com/j/0CDA1B270B","application_url":"https://apply.workable.com/j/0CDA1B270B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"10BABFFCB4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/10BABFFCB4","shortlink":"https://apply.workable.com/j/10BABFFCB4","application_url":"https://apply.workable.com/j/10BABFFCB4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"2DB056769B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2DB056769B","shortlink":"https://apply.workable.com/j/2DB056769B","application_url":"https://apply.workable.com/j/2DB056769B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rocky Mount","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rocky Mount","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"8E9E2FFE5B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8E9E2FFE5B","shortlink":"https://apply.workable.com/j/8E9E2FFE5B","application_url":"https://apply.workable.com/j/8E9E2FFE5B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"F6EECE6D56","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F6EECE6D56","shortlink":"https://apply.workable.com/j/F6EECE6D56","application_url":"https://apply.workable.com/j/F6EECE6D56/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"B57FDA9C64","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B57FDA9C64","shortlink":"https://apply.workable.com/j/B57FDA9C64","application_url":"https://apply.workable.com/j/B57FDA9C64/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"569916377E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/569916377E","shortlink":"https://apply.workable.com/j/569916377E","application_url":"https://apply.workable.com/j/569916377E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"558B3E5F4B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/558B3E5F4B","shortlink":"https://apply.workable.com/j/558B3E5F4B","application_url":"https://apply.workable.com/j/558B3E5F4B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0146117894","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0146117894","shortlink":"https://apply.workable.com/j/0146117894","application_url":"https://apply.workable.com/j/0146117894/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0CE73A1CA1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CE73A1CA1","shortlink":"https://apply.workable.com/j/0CE73A1CA1","application_url":"https://apply.workable.com/j/0CE73A1CA1/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Home Improvement Sales Representative","shortcode":"839DE32659","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/839DE32659","shortlink":"https://apply.workable.com/j/839DE32659","application_url":"https://apply.workable.com/j/839DE32659/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"58C35F73A2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/58C35F73A2","shortlink":"https://apply.workable.com/j/58C35F73A2","application_url":"https://apply.workable.com/j/58C35F73A2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"A3B3E81B4B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A3B3E81B4B","shortlink":"https://apply.workable.com/j/A3B3E81B4B","application_url":"https://apply.workable.com/j/A3B3E81B4B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"464BF35316","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/464BF35316","shortlink":"https://apply.workable.com/j/464BF35316","application_url":"https://apply.workable.com/j/464BF35316/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, your primary responsibility will be to sell roofing products and services to homeowners. This role entails meeting with homeowners, evaluating their roofing requirements, offering recommendations for products and services, and ultimately closing sales. The company will provide qualified leads, so there is no need for cold calling. In this role, your specific tasks will include: </p><ul> <li>Conducting 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Achieving sales targets by closing sales</li> <li>Providing exceptional customer service throughout the sales process</li> <li>Attending trainings and staying up-to-date on company products and services</li> <li>Driving to pre-set appointments; no cold calling or door knocking required</li> <li>Completing a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attending regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul>"},{"title":"Home Improvement Sales Representative","shortcode":"C65E42369E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C65E42369E","shortlink":"https://apply.workable.com/j/C65E42369E","application_url":"https://apply.workable.com/j/C65E42369E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"9761AE0AB3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9761AE0AB3","shortlink":"https://apply.workable.com/j/9761AE0AB3","application_url":"https://apply.workable.com/j/9761AE0AB3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"50C4C85600","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/50C4C85600","shortlink":"https://apply.workable.com/j/50C4C85600","application_url":"https://apply.workable.com/j/50C4C85600/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Inside Sales/Customer Service Representative","shortcode":"A990B43C15","code":"","employment_type":"Full-time","telecommuting":false,"department":"Call Center","url":"https://apply.workable.com/j/A990B43C15","shortlink":"https://apply.workable.com/j/A990B43C15","application_url":"https://apply.workable.com/j/A990B43C15/apply","published_on":"2024-01-03","created_at":"2024-01-03","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Customer Service","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Southern National is seeking an enthusiastic and friendly Inside Sales/Customer Service Representative to join our team! Our professional roofing company focuses on energy-efficient residential roofing replacement, specializing in products and installation methods that cater to the unique climate and building challenges in the southeastern United States. We are certified to install most roofing brands, including North America's top-selling Timberline® roofing shingles by GAF. As an integral part of our team, you will be responsible for providing exceptional customer service to our existing and potential clients.</p><p><br></p> <h3>Responsibilities</h3><ul> <li>Field inbound calls from our field marketing team as well as clients and prospective clients to schedule appointments</li> <li>Daily telephone interaction with our database of customers and prospects</li> <li>Promotion of our eco-friendly products and services to prospective and existing clients</li> <li>Generation of appointments for our outside sales division</li> <li>Ongoing department meetings and training</li> </ul><p><strong>Requirements</strong></p><ul> <li>2+ years of experience in inside sales or customer service.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to handle high-stress situations in a calm and professional manner.</li> <li>Excellent problem-solving and critical-thinking skills.</li> <li>Familiarity with Microsoft Office and CRM systems (Salesforce, Hubspot, etc.).</li> <li>Ability to multitask, prioritize, and manage time effectively.</li> <li>A positive attitude, a thirst for knowledge, and a genuine desire to help customers.</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first year income range: $35,000 - $50,000 (Base Salary plus commission and bonuses)</li> <li>Weekly and monthly opportunities for performance-based rewards</li> <li>Full medical, dental, life and disability insurance</li> <li>Access to the latest technology</li> <li>Unlimited growth opportunity</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"3D7028BFAC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3D7028BFAC","shortlink":"https://apply.workable.com/j/3D7028BFAC","application_url":"https://apply.workable.com/j/3D7028BFAC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"1D3B1AE63B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1D3B1AE63B","shortlink":"https://apply.workable.com/j/1D3B1AE63B","application_url":"https://apply.workable.com/j/1D3B1AE63B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"AEA17B7870","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AEA17B7870","shortlink":"https://apply.workable.com/j/AEA17B7870","application_url":"https://apply.workable.com/j/AEA17B7870/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"BCDDE362E6","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/BCDDE362E6","shortlink":"https://apply.workable.com/j/BCDDE362E6","application_url":"https://apply.workable.com/j/BCDDE362E6/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"872088EAF5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/872088EAF5","shortlink":"https://apply.workable.com/j/872088EAF5","application_url":"https://apply.workable.com/j/872088EAF5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"A75215093C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A75215093C","shortlink":"https://apply.workable.com/j/A75215093C","application_url":"https://apply.workable.com/j/A75215093C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Not Applicable","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Our top 2% roofing company is seeking a Senior Sales Representative to join our team. With multiple locations across multiple states, this is a unique opportunity to join a successful team and grow with our company. In this role, you will be responsible for selling roofing products and services to homeowners. It is important to note that this role does not require cold calling - all leads are provided by the company. As a Senior Sales Representative, your job is to close the sale. We are looking for closers!</p><p>Candidates must live within 45 miles of the office location.</p><p>Extensive paid training is provided, and mandatory, for all hires.</p><p>Key Responsibilities:</p><ul> <li>Meet with homeowners to assess their roofing needs and provide product and service recommendations</li> <li>Close sales and achieve sales targets</li> <li>Collaborate with our team of roofing professionals to develop custom solutions for homeowners</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and product knowledge seminars to stay up-to-date on company products and services</li> </ul><p>This position offers an expected earning of $80,000 - $120,000 per year, with potential for growth and advancement within our company. If you are a driven and experienced sales professional with a passion for providing excellent customer service, and a proven ability to close sales, we want to hear from you.</p><p>Apply today to become our next Senior Sales Representative!</p><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and weekends as needed</li> <li>Valid driver's license and reliable transportation</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"18EBA9B65A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/18EBA9B65A","shortlink":"https://apply.workable.com/j/18EBA9B65A","application_url":"https://apply.workable.com/j/18EBA9B65A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Regional Sales Executive","shortcode":"15D265A62C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/15D265A62C","shortlink":"https://apply.workable.com/j/15D265A62C","application_url":"https://apply.workable.com/j/15D265A62C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"C499FE8EEE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C499FE8EEE","shortlink":"https://apply.workable.com/j/C499FE8EEE","application_url":"https://apply.workable.com/j/C499FE8EEE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"AF22A61836","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AF22A61836","shortlink":"https://apply.workable.com/j/AF22A61836","application_url":"https://apply.workable.com/j/AF22A61836/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"3955A4DB40","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3955A4DB40","shortlink":"https://apply.workable.com/j/3955A4DB40","application_url":"https://apply.workable.com/j/3955A4DB40/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"3253BB167A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3253BB167A","shortlink":"https://apply.workable.com/j/3253BB167A","application_url":"https://apply.workable.com/j/3253BB167A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"DD9508396C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DD9508396C","shortlink":"https://apply.workable.com/j/DD9508396C","application_url":"https://apply.workable.com/j/DD9508396C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"E882D42A06","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E882D42A06","shortlink":"https://apply.workable.com/j/E882D42A06","application_url":"https://apply.workable.com/j/E882D42A06/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"224BB4B6CA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/224BB4B6CA","shortlink":"https://apply.workable.com/j/224BB4B6CA","application_url":"https://apply.workable.com/j/224BB4B6CA/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"7C5F6060E3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7C5F6060E3","shortlink":"https://apply.workable.com/j/7C5F6060E3","application_url":"https://apply.workable.com/j/7C5F6060E3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"EA5ADB0C08","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EA5ADB0C08","shortlink":"https://apply.workable.com/j/EA5ADB0C08","application_url":"https://apply.workable.com/j/EA5ADB0C08/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"99D0A73A3E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/99D0A73A3E","shortlink":"https://apply.workable.com/j/99D0A73A3E","application_url":"https://apply.workable.com/j/99D0A73A3E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"72F7698000","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/72F7698000","shortlink":"https://apply.workable.com/j/72F7698000","application_url":"https://apply.workable.com/j/72F7698000/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"4600E23866","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4600E23866","shortlink":"https://apply.workable.com/j/4600E23866","application_url":"https://apply.workable.com/j/4600E23866/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"B7CD0E6157","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B7CD0E6157","shortlink":"https://apply.workable.com/j/B7CD0E6157","application_url":"https://apply.workable.com/j/B7CD0E6157/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Roofing Sales Representative","shortcode":"0FA552776B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0FA552776B","shortlink":"https://apply.workable.com/j/0FA552776B","application_url":"https://apply.workable.com/j/0FA552776B/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"C4800ABB7A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C4800ABB7A","shortlink":"https://apply.workable.com/j/C4800ABB7A","application_url":"https://apply.workable.com/j/C4800ABB7A/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"C5DF994717","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C5DF994717","shortlink":"https://apply.workable.com/j/C5DF994717","application_url":"https://apply.workable.com/j/C5DF994717/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"D9630B2BA7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/D9630B2BA7","shortlink":"https://apply.workable.com/j/D9630B2BA7","application_url":"https://apply.workable.com/j/D9630B2BA7/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"1EF7CA141C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1EF7CA141C","shortlink":"https://apply.workable.com/j/1EF7CA141C","application_url":"https://apply.workable.com/j/1EF7CA141C/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"B4E8C2D84D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B4E8C2D84D","shortlink":"https://apply.workable.com/j/B4E8C2D84D","application_url":"https://apply.workable.com/j/B4E8C2D84D/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"735C13B256","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/735C13B256","shortlink":"https://apply.workable.com/j/735C13B256","application_url":"https://apply.workable.com/j/735C13B256/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Senior Sales Representative","shortcode":"4A90F1940C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4A90F1940C","shortlink":"https://apply.workable.com/j/4A90F1940C","application_url":"https://apply.workable.com/j/4A90F1940C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"83D57A570A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/83D57A570A","shortlink":"https://apply.workable.com/j/83D57A570A","application_url":"https://apply.workable.com/j/83D57A570A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"F65438B9D2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F65438B9D2","shortlink":"https://apply.workable.com/j/F65438B9D2","application_url":"https://apply.workable.com/j/F65438B9D2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"CABB143C25","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CABB143C25","shortlink":"https://apply.workable.com/j/CABB143C25","application_url":"https://apply.workable.com/j/CABB143C25/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"7CAFFBD8C9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7CAFFBD8C9","shortlink":"https://apply.workable.com/j/7CAFFBD8C9","application_url":"https://apply.workable.com/j/7CAFFBD8C9/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"2AFD4D702A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2AFD4D702A","shortlink":"https://apply.workable.com/j/2AFD4D702A","application_url":"https://apply.workable.com/j/2AFD4D702A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"57B80EB15B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/57B80EB15B","shortlink":"https://apply.workable.com/j/57B80EB15B","application_url":"https://apply.workable.com/j/57B80EB15B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"}]}
-  recorded_at: Mon, 29 Jul 2024 09:14:34 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:32 GMT
 - request:
     method: get
     uri: https://apply.workable.com/api/v1/accounts/southern-national
@@ -85,7 +85,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:34 GMT
+      - Tue, 30 Jul 2024 16:26:32 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -99,11 +99,11 @@ http_interactions:
       Access-Control-Allow-Credentials:
       - 'true'
       Set-Cookie:
-      - __cf_bm=kBfKgVMAL24DaNH3bKrdNnCxAeTEK93mVJAE2vUK8pY-1722244474-1.0.1.1-zfyHP1nUF8H0XyTFrO3UKzHylU0LMSIQ1ymS6r.ia2sqXuXe8wKzpz6ief9e8Ovyl41i5ktASvyQvu.Xog3cvQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:34 GMT; domain=.workable.com; HttpOnly;
+      - __cf_bm=AwQCbrb_8PrjciHoWL3df5eawOM3XVl1EGaMLZuvzlE-1722356792-1.0.1.1-81JqfmeF_jTE5NhKyCSviKVMVx6YwC0UVuAncbzQzo7XhzTsQi_cAdB1idzyORUCC6VYQ7Et82w8CteuEqlHow;
+        path=/; expires=Tue, 30-Jul-24 16:56:32 GMT; domain=.workable.com; HttpOnly;
         Secure; SameSite=None
-      - wmc=%7B%22cookie_id%22%3A%2232e24986-9848-4e09-88a4-a3388e930213%22%7D; path=/;
-        expires=Sat, 29 Jul 2034 21:14:34 GMT; domain=.workable.com; samesite=none;
+      - wmc=%7B%22cookie_id%22%3A%220151930a-f59a-4395-8789-d40c0c5e224c%22%7D; path=/;
+        expires=Mon, 31 Jul 2034 04:26:32 GMT; domain=.workable.com; samesite=none;
         secure
       Expect-Ct:
       - enforce, max-age=86400
@@ -122,16 +122,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabffdf8878889b
+      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b600b9219405
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabffdf8878889b-LHR
+      - 8ab6b600b9219405-LHR
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         eyJpZCI6NjAzMTU2LCJ1aWQiOiJiNzI0MzYyMi01Y2M5LTQ1NzItOWQ1Mi1lNzZjZDYyZDg1ZDgiLCJsb2dvIjoiaHR0cHM6Ly93b3JrYWJsZWhyLnMzLmFtYXpvbmF3cy5jb20vdXBsb2Fkcy9hY2NvdW50L2xvZ28vNjAzMTU2L2xvZ28iLCJzdWJkb21haW4iOiJzb3V0aGVybi1uYXRpb25hbCIsIm5hbWUiOiJTb3V0aGVybiBOYXRpb25hbCBSb29maW5nIiwidXJsIjoiaHR0cDovL3d3dy5zb3V0aGVybm5hdGlvbmFsLmNvbS8iLCJsYW5ndWFnZXMiOnsiZGVmYXVsdCI6ImVuIiwib3B0aW9ucyI6W3sibmFtZSI6ImVuIiwicHVibGlzaGVkIjp0cnVlLCJlbmFibGVkIjp0cnVlLCJ2aXNpYmxlIjp0cnVlfV19LCJkZXRhaWxzIjp7Im92ZXJ2aWV3Ijp7ImRlc2NyaXB0aW9uIjoiPHA+U291dGhlcm4gTmF0aW9uYWwgUm9vZmluZyBpcyBhIHByb2Zlc3Npb25hbCByb29maW5nIGNvbnRyYWN0b3IgdGhhdCBmb2N1c2VzIG9uIGVuZXJneS1lZmZpY2llbnQgcmVzaWRlbnRpYWwgcm9vZmluZyByZXBsYWNlbWVudCwgdXNpbmcgcHJvZHVjdHMgYW5kIGluc3RhbGxhdGlvbiBtZXRob2RzIGdlYXJlZCB0byB0aGUgdW5pcXVlIGNsaW1hdGUgYW5kIGJ1aWxkaW5nIGNoYWxsZW5nZXMgaW4gdGhlIHNvdXRoZWFzdGVybiBVbml0ZWQgU3RhdGVzLiBXZSBhcmUgY2VydGlmaWVkIHRvIGluc3RhbGwgbW9zdCByb29maW5nIGJyYW5kcyBpbmNsdWRpbmcgcHJvZHVjdHMgZnJvbSBHQUYsIHRoZSBtYW51ZmFjdHVyZXIgb2YgTm9ydGggQW1lcmljYeKAmXMgIzEtc2VsbGluZyBUaW1iZXJsaW5lwq4gcm9vZmluZyBzaGluZ2xlcy48L3A+In0sIm9mY2NwIjpmYWxzZSwibWFpbGJveCI6eyJlbmFibGVkIjpmYWxzZSwidGV4dCI6bnVsbCwiZW1haWwiOiJzb3V0aGVybi1uYXRpb25hbEBqb2JzLndvcmthYmxlbWFpbC5jb20ifSwiZ3Vlc3NBdmF0YXIiOnRydWUsImFwcGx5V2l0aEluZGVlZCI6dHJ1ZSwiZGVwYXJ0bWVudHNQdWJsaWNMZXZlbCI6Mn19
-  recorded_at: Mon, 29 Jul 2024 09:14:34 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:32 GMT
 - request:
     method: get
     uri: https://www.workable.com/api/accounts/southern-national?details=true
@@ -151,7 +151,7 @@ http_interactions:
       message: Moved Temporarily
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:35 GMT
+      - Tue, 30 Jul 2024 16:26:32 GMT
       Content-Type:
       - text/html
       Content-Length:
@@ -165,8 +165,8 @@ http_interactions:
       Location:
       - https://apply.workable.com/api/v1/widget/accounts/southern-national?details=true
       Set-Cookie:
-      - __cf_bm=XF6GEBCIEV5vCsSwqO6bvJBAuml4d0hCRuJmwuhelgI-1722244475-1.0.1.1-0Aeh0sNCKgXtUf1g_Bup4BRlRkUZU19dm3e7es1mXKBRGoZfmqNiI_61idT5RK2nVp2HUofewnK.A5fZYfOvjQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:35 GMT; domain=.workable.com; HttpOnly;
+      - __cf_bm=4c5U1AXbkkHe2RzrCYHC6JqqtxcrxLmZZ9U902oCuLw-1722356792-1.0.1.1-_tZ_1E9YBHEAtIb6xw2yGDMyyO7YLpDGBJWLwpx1t12.DgTc0i4sL87sr6TjsYMWFxeFT3b_XqAZqxxaixOB9A;
+        path=/; expires=Tue, 30-Jul-24 16:56:32 GMT; domain=.workable.com; HttpOnly;
         Secure; SameSite=None
       Vary:
       - Accept-Encoding
@@ -177,16 +177,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors https://*.workable.com/; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabffe09bbe63e5
+      - frame-ancestors https://*.workable.com/; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b601db7c93e0
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabffe09bbe63e5-LHR
+      - 8ab6b601db7c93e0-LHR
     body:
       encoding: UTF-8
       string: "<html>\r\n<head><title>302 Found</title></head>\r\n<body>\r\n<center><h1>302
         Found</h1></center>\r\n<hr><center>cloudflare</center>\r\n</body>\r\n</html>\r\n"
-  recorded_at: Mon, 29 Jul 2024 09:14:35 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:32 GMT
 - request:
     method: get
     uri: https://apply.workable.com/api/v1/widget/accounts/southern-national?details=true
@@ -197,7 +197,7 @@ http_interactions:
       Accept:
       - application/json
       Cookie:
-      - __cf_bm=XF6GEBCIEV5vCsSwqO6bvJBAuml4d0hCRuJmwuhelgI-1722244475-1.0.1.1-0Aeh0sNCKgXtUf1g_Bup4BRlRkUZU19dm3e7es1mXKBRGoZfmqNiI_61idT5RK2nVp2HUofewnK.A5fZYfOvjQ
+      - __cf_bm=4c5U1AXbkkHe2RzrCYHC6JqqtxcrxLmZZ9U902oCuLw-1722356792-1.0.1.1-_tZ_1E9YBHEAtIb6xw2yGDMyyO7YLpDGBJWLwpx1t12.DgTc0i4sL87sr6TjsYMWFxeFT3b_XqAZqxxaixOB9A
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       User-Agent:
@@ -208,7 +208,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:35 GMT
+      - Tue, 30 Jul 2024 16:26:32 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -220,8 +220,8 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Set-Cookie:
-      - wmc=%7B%22cookie_id%22%3A%222f70db03-9117-4c78-9706-1bf1aabf0bc5%22%7D; path=/;
-        expires=Sat, 29 Jul 2034 21:14:35 GMT; domain=.workable.com; samesite=none;
+      - wmc=%7B%22cookie_id%22%3A%22fc036ee0-ad07-4fec-9744-fbe79fbdcd58%22%7D; path=/;
+        expires=Mon, 31 Jul 2034 04:26:32 GMT; domain=.workable.com; samesite=none;
         secure
       Expect-Ct:
       - enforce, max-age=86400
@@ -242,16 +242,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabffe109a89454
+      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b6022d70417d
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabffe109a89454-LHR
+      - 8ab6b6022d70417d-LHR
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         {"name":"Southern National Roofing","description":"<p>Southern National Roofing is a professional roofing contractor that focuses on energy-efficient residential roofing replacement, using products and installation methods geared to the unique climate and building challenges in the southeastern United States. We are certified to install most roofing brands including products from GAF, the manufacturer of North America’s #1-selling Timberline® roofing shingles.</p>","jobs":[{"title":"Appointment Setter","shortcode":"7659BE0024","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7659BE0024","shortlink":"https://apply.workable.com/j/7659BE0024","application_url":"https://apply.workable.com/j/7659BE0024/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our WILMINGTON, DE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"E07D9D1957","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E07D9D1957","shortlink":"https://apply.workable.com/j/E07D9D1957","application_url":"https://apply.workable.com/j/E07D9D1957/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our WILMINGTON, DE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"AB7BE627E1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AB7BE627E1","shortlink":"https://apply.workable.com/j/AB7BE627E1","application_url":"https://apply.workable.com/j/AB7BE627E1/apply","published_on":"2023-10-02","created_at":"2023-10-02","country":"United States","city":"Charleston","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charleston","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLESTON, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"41BBB2DBE8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/41BBB2DBE8","shortlink":"https://apply.workable.com/j/41BBB2DBE8","application_url":"https://apply.workable.com/j/41BBB2DBE8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"8DDDAAAA55","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8DDDAAAA55","shortlink":"https://apply.workable.com/j/8DDDAAAA55","application_url":"https://apply.workable.com/j/8DDDAAAA55/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"2248DDE46A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2248DDE46A","shortlink":"https://apply.workable.com/j/2248DDE46A","application_url":"https://apply.workable.com/j/2248DDE46A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"FC1DD2FEAF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/FC1DD2FEAF","shortlink":"https://apply.workable.com/j/FC1DD2FEAF","application_url":"https://apply.workable.com/j/FC1DD2FEAF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"11F35D391A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/11F35D391A","shortlink":"https://apply.workable.com/j/11F35D391A","application_url":"https://apply.workable.com/j/11F35D391A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"1C3EC2297A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1C3EC2297A","shortlink":"https://apply.workable.com/j/1C3EC2297A","application_url":"https://apply.workable.com/j/1C3EC2297A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"F207EEB77B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F207EEB77B","shortlink":"https://apply.workable.com/j/F207EEB77B","application_url":"https://apply.workable.com/j/F207EEB77B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A62C7FFB5A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A62C7FFB5A","shortlink":"https://apply.workable.com/j/A62C7FFB5A","application_url":"https://apply.workable.com/j/A62C7FFB5A/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"25A426104D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/25A426104D","shortlink":"https://apply.workable.com/j/25A426104D","application_url":"https://apply.workable.com/j/25A426104D/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"581F2DF689","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/581F2DF689","shortlink":"https://apply.workable.com/j/581F2DF689","application_url":"https://apply.workable.com/j/581F2DF689/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"944FEC96C0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/944FEC96C0","shortlink":"https://apply.workable.com/j/944FEC96C0","application_url":"https://apply.workable.com/j/944FEC96C0/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"8A4756A19F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8A4756A19F","shortlink":"https://apply.workable.com/j/8A4756A19F","application_url":"https://apply.workable.com/j/8A4756A19F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Annapolis","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Annapolis","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"2A241C2A74","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2A241C2A74","shortlink":"https://apply.workable.com/j/2A241C2A74","application_url":"https://apply.workable.com/j/2A241C2A74/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"E43D5A9F14","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E43D5A9F14","shortlink":"https://apply.workable.com/j/E43D5A9F14","application_url":"https://apply.workable.com/j/E43D5A9F14/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"4D05F16C78","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4D05F16C78","shortlink":"https://apply.workable.com/j/4D05F16C78","application_url":"https://apply.workable.com/j/4D05F16C78/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"0C9781DB0B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0C9781DB0B","shortlink":"https://apply.workable.com/j/0C9781DB0B","application_url":"https://apply.workable.com/j/0C9781DB0B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"15258E3B5B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/15258E3B5B","shortlink":"https://apply.workable.com/j/15258E3B5B","application_url":"https://apply.workable.com/j/15258E3B5B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"17FAD80C09","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/17FAD80C09","shortlink":"https://apply.workable.com/j/17FAD80C09","application_url":"https://apply.workable.com/j/17FAD80C09/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"0A0F60C4F2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0A0F60C4F2","shortlink":"https://apply.workable.com/j/0A0F60C4F2","application_url":"https://apply.workable.com/j/0A0F60C4F2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"3E59F76FAC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3E59F76FAC","shortlink":"https://apply.workable.com/j/3E59F76FAC","application_url":"https://apply.workable.com/j/3E59F76FAC/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"C7735D4CB9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C7735D4CB9","shortlink":"https://apply.workable.com/j/C7735D4CB9","application_url":"https://apply.workable.com/j/C7735D4CB9/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A8CCE563D7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A8CCE563D7","shortlink":"https://apply.workable.com/j/A8CCE563D7","application_url":"https://apply.workable.com/j/A8CCE563D7/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"1A1E53B755","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1A1E53B755","shortlink":"https://apply.workable.com/j/1A1E53B755","application_url":"https://apply.workable.com/j/1A1E53B755/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A32A8A4288","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A32A8A4288","shortlink":"https://apply.workable.com/j/A32A8A4288","application_url":"https://apply.workable.com/j/A32A8A4288/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"62A962AFFF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/62A962AFFF","shortlink":"https://apply.workable.com/j/62A962AFFF","application_url":"https://apply.workable.com/j/62A962AFFF/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"4690BDDD33","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4690BDDD33","shortlink":"https://apply.workable.com/j/4690BDDD33","application_url":"https://apply.workable.com/j/4690BDDD33/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"DB9371FBC2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DB9371FBC2","shortlink":"https://apply.workable.com/j/DB9371FBC2","application_url":"https://apply.workable.com/j/DB9371FBC2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"CADC40FD39","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CADC40FD39","shortlink":"https://apply.workable.com/j/CADC40FD39","application_url":"https://apply.workable.com/j/CADC40FD39/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"8708710B12","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8708710B12","shortlink":"https://apply.workable.com/j/8708710B12","application_url":"https://apply.workable.com/j/8708710B12/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Exciting Opportunity for Young Marketing Enthusiasts!</p><p>Are you a young marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2E4E713D75","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2E4E713D75","shortlink":"https://apply.workable.com/j/2E4E713D75","application_url":"https://apply.workable.com/j/2E4E713D75/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity for Young Marketing Enthusiasts!</p><p>Are you a young marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A02BA6B18F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A02BA6B18F","shortlink":"https://apply.workable.com/j/A02BA6B18F","application_url":"https://apply.workable.com/j/A02BA6B18F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"66B9765E1F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/66B9765E1F","shortlink":"https://apply.workable.com/j/66B9765E1F","application_url":"https://apply.workable.com/j/66B9765E1F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"C6ED49CCC5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C6ED49CCC5","shortlink":"https://apply.workable.com/j/C6ED49CCC5","application_url":"https://apply.workable.com/j/C6ED49CCC5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"33D771BD6F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/33D771BD6F","shortlink":"https://apply.workable.com/j/33D771BD6F","application_url":"https://apply.workable.com/j/33D771BD6F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A7ECEBBA42","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A7ECEBBA42","shortlink":"https://apply.workable.com/j/A7ECEBBA42","application_url":"https://apply.workable.com/j/A7ECEBBA42/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"9B3E0AE0F7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9B3E0AE0F7","shortlink":"https://apply.workable.com/j/9B3E0AE0F7","application_url":"https://apply.workable.com/j/9B3E0AE0F7/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"64D4F974C2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/64D4F974C2","shortlink":"https://apply.workable.com/j/64D4F974C2","application_url":"https://apply.workable.com/j/64D4F974C2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2DD07239C2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2DD07239C2","shortlink":"https://apply.workable.com/j/2DD07239C2","application_url":"https://apply.workable.com/j/2DD07239C2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"3E5C44463A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3E5C44463A","shortlink":"https://apply.workable.com/j/3E5C44463A","application_url":"https://apply.workable.com/j/3E5C44463A/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"EB4BD2DF9C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EB4BD2DF9C","shortlink":"https://apply.workable.com/j/EB4BD2DF9C","application_url":"https://apply.workable.com/j/EB4BD2DF9C/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"093D7AD59F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/093D7AD59F","shortlink":"https://apply.workable.com/j/093D7AD59F","application_url":"https://apply.workable.com/j/093D7AD59F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2176505A35","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2176505A35","shortlink":"https://apply.workable.com/j/2176505A35","application_url":"https://apply.workable.com/j/2176505A35/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"7F5AF2FD27","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7F5AF2FD27","shortlink":"https://apply.workable.com/j/7F5AF2FD27","application_url":"https://apply.workable.com/j/7F5AF2FD27/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"131A4B882F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/131A4B882F","shortlink":"https://apply.workable.com/j/131A4B882F","application_url":"https://apply.workable.com/j/131A4B882F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"69E00CB8BA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/69E00CB8BA","shortlink":"https://apply.workable.com/j/69E00CB8BA","application_url":"https://apply.workable.com/j/69E00CB8BA/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"927846AF02","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/927846AF02","shortlink":"https://apply.workable.com/j/927846AF02","application_url":"https://apply.workable.com/j/927846AF02/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"E4FF1BBBC9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E4FF1BBBC9","shortlink":"https://apply.workable.com/j/E4FF1BBBC9","application_url":"https://apply.workable.com/j/E4FF1BBBC9/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"4FD957F151","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4FD957F151","shortlink":"https://apply.workable.com/j/4FD957F151","application_url":"https://apply.workable.com/j/4FD957F151/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"4E224B9A7C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4E224B9A7C","shortlink":"https://apply.workable.com/j/4E224B9A7C","application_url":"https://apply.workable.com/j/4E224B9A7C/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"53BE062C2B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/53BE062C2B","shortlink":"https://apply.workable.com/j/53BE062C2B","application_url":"https://apply.workable.com/j/53BE062C2B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"0723474365","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0723474365","shortlink":"https://apply.workable.com/j/0723474365","application_url":"https://apply.workable.com/j/0723474365/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A5519A4680","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A5519A4680","shortlink":"https://apply.workable.com/j/A5519A4680","application_url":"https://apply.workable.com/j/A5519A4680/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"622803D6DD","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/622803D6DD","shortlink":"https://apply.workable.com/j/622803D6DD","application_url":"https://apply.workable.com/j/622803D6DD/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Recruiter","shortcode":"11625446FB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Recruiting","url":"https://apply.workable.com/j/11625446FB","shortlink":"https://apply.workable.com/j/11625446FB","application_url":"https://apply.workable.com/j/11625446FB/apply","published_on":"2024-02-23","created_at":"2024-02-23","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Human Resources","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Join Our Team as an Entry Level Recruiter!</p><p>Southern National Roofing is a rapidly growing roofing and home improvement company, and we're seeking motivated individuals to join our HR department as entry-level recruiters. As an entry-level recruiter, you'll play a crucial role in attracting and selecting top talent that aligns with our company's values and goals.</p><p>Why Join Us?</p><p>At Southern National Roofing, we value our employees and their professional growth. As an entry-level recruiter, you'll have the opportunity to learn and grow in a supportive and collaborative environment. We provide comprehensive training and development programs, ensuring that you have the necessary skills and knowledge to excel in your role. Join our team and be part of an exciting journey as we continue to expand and make a difference in the lives of homeowners through our high-quality roofing solutions.</p><p>Key Responsibilities:</p><ul> <li>Assist with sourcing, screening, and selecting candidates for open positions</li> <li>Conduct phone and in-person interviews to assess candidate qualifications</li> <li>Coordinate and schedule interviews with hiring managers</li> <li>Manage the applicant tracking system and maintain accurate candidate records</li> <li>Assist with onboarding new hires and conducting orientation sessions</li> </ul><p></p><p>This position requires daily attendance in our Charlotte, NC office.</p><p><strong>Requirements</strong></p><ul> <li>High school diploma or equivalent</li> <li>Strong communication and interpersonal skills</li> <li>Ability to work with a sense of urgency and meet deadlines</li> <li>Attention to detail and strong organizational skills</li> <li>Proficiency in Microsoft Office Suite</li> <li>Ability to maintain confidentiality and handle sensitive information</li> <li>Prior experience in recruitment or HR is a plus, but not required</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $50,000+ (Base Salary + Commission + Bonuses)</li> <li>Medical and Mental Health Benefits</li> <li>Paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"A5599863A0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A5599863A0","shortlink":"https://apply.workable.com/j/A5599863A0","application_url":"https://apply.workable.com/j/A5599863A0/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"B705ED5163","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B705ED5163","shortlink":"https://apply.workable.com/j/B705ED5163","application_url":"https://apply.workable.com/j/B705ED5163/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"53E26D14D3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/53E26D14D3","shortlink":"https://apply.workable.com/j/53E26D14D3","application_url":"https://apply.workable.com/j/53E26D14D3/apply","published_on":"2024-04-29","created_at":"2024-04-29","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"85C117F6B3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/85C117F6B3","shortlink":"https://apply.workable.com/j/85C117F6B3","application_url":"https://apply.workable.com/j/85C117F6B3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"13CFEF8FF3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/13CFEF8FF3","shortlink":"https://apply.workable.com/j/13CFEF8FF3","application_url":"https://apply.workable.com/j/13CFEF8FF3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"8928451BA2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8928451BA2","shortlink":"https://apply.workable.com/j/8928451BA2","application_url":"https://apply.workable.com/j/8928451BA2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"E1585E246E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E1585E246E","shortlink":"https://apply.workable.com/j/E1585E246E","application_url":"https://apply.workable.com/j/E1585E246E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"083A5D36C9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/083A5D36C9","shortlink":"https://apply.workable.com/j/083A5D36C9","application_url":"https://apply.workable.com/j/083A5D36C9/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Monroe","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Monroe","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"13D9050FD4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/13D9050FD4","shortlink":"https://apply.workable.com/j/13D9050FD4","application_url":"https://apply.workable.com/j/13D9050FD4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lexington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lexington","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"B551BB4828","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B551BB4828","shortlink":"https://apply.workable.com/j/B551BB4828","application_url":"https://apply.workable.com/j/B551BB4828/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"CD35F1E9F8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CD35F1E9F8","shortlink":"https://apply.workable.com/j/CD35F1E9F8","application_url":"https://apply.workable.com/j/CD35F1E9F8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"4E3244D221","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4E3244D221","shortlink":"https://apply.workable.com/j/4E3244D221","application_url":"https://apply.workable.com/j/4E3244D221/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"0432F47723","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0432F47723","shortlink":"https://apply.workable.com/j/0432F47723","application_url":"https://apply.workable.com/j/0432F47723/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"5542FD5BBF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5542FD5BBF","shortlink":"https://apply.workable.com/j/5542FD5BBF","application_url":"https://apply.workable.com/j/5542FD5BBF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"DB7FEDE601","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DB7FEDE601","shortlink":"https://apply.workable.com/j/DB7FEDE601","application_url":"https://apply.workable.com/j/DB7FEDE601/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"334D7BBB28","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/334D7BBB28","shortlink":"https://apply.workable.com/j/334D7BBB28","application_url":"https://apply.workable.com/j/334D7BBB28/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"EF0C15C19D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EF0C15C19D","shortlink":"https://apply.workable.com/j/EF0C15C19D","application_url":"https://apply.workable.com/j/EF0C15C19D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"4759A849E8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4759A849E8","shortlink":"https://apply.workable.com/j/4759A849E8","application_url":"https://apply.workable.com/j/4759A849E8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Asheboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Asheboro","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"319D2CDFAF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/319D2CDFAF","shortlink":"https://apply.workable.com/j/319D2CDFAF","application_url":"https://apply.workable.com/j/319D2CDFAF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"19499025B5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/19499025B5","shortlink":"https://apply.workable.com/j/19499025B5","application_url":"https://apply.workable.com/j/19499025B5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"C9588F86D4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C9588F86D4","shortlink":"https://apply.workable.com/j/C9588F86D4","application_url":"https://apply.workable.com/j/C9588F86D4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"FD12F1A3AB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/FD12F1A3AB","shortlink":"https://apply.workable.com/j/FD12F1A3AB","application_url":"https://apply.workable.com/j/FD12F1A3AB/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"2356649AF4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2356649AF4","shortlink":"https://apply.workable.com/j/2356649AF4","application_url":"https://apply.workable.com/j/2356649AF4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F72156267A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F72156267A","shortlink":"https://apply.workable.com/j/F72156267A","application_url":"https://apply.workable.com/j/F72156267A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"CD45C95CB3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CD45C95CB3","shortlink":"https://apply.workable.com/j/CD45C95CB3","application_url":"https://apply.workable.com/j/CD45C95CB3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Fayetteville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Fayetteville","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"75560CA15F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/75560CA15F","shortlink":"https://apply.workable.com/j/75560CA15F","application_url":"https://apply.workable.com/j/75560CA15F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"3BBED68423","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3BBED68423","shortlink":"https://apply.workable.com/j/3BBED68423","application_url":"https://apply.workable.com/j/3BBED68423/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F0D77C7277","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F0D77C7277","shortlink":"https://apply.workable.com/j/F0D77C7277","application_url":"https://apply.workable.com/j/F0D77C7277/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rocky Mount","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rocky Mount","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"7277358208","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7277358208","shortlink":"https://apply.workable.com/j/7277358208","application_url":"https://apply.workable.com/j/7277358208/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"E124EBD0D0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E124EBD0D0","shortlink":"https://apply.workable.com/j/E124EBD0D0","application_url":"https://apply.workable.com/j/E124EBD0D0/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"40F78FA40D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/40F78FA40D","shortlink":"https://apply.workable.com/j/40F78FA40D","application_url":"https://apply.workable.com/j/40F78FA40D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"32BA38FC76","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/32BA38FC76","shortlink":"https://apply.workable.com/j/32BA38FC76","application_url":"https://apply.workable.com/j/32BA38FC76/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"0CA3CDBE73","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CA3CDBE73","shortlink":"https://apply.workable.com/j/0CA3CDBE73","application_url":"https://apply.workable.com/j/0CA3CDBE73/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F14C3BCA12","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F14C3BCA12","shortlink":"https://apply.workable.com/j/F14C3BCA12","application_url":"https://apply.workable.com/j/F14C3BCA12/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Exciting Opportunity for Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"C8BDCF23EC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C8BDCF23EC","shortlink":"https://apply.workable.com/j/C8BDCF23EC","application_url":"https://apply.workable.com/j/C8BDCF23EC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Annapolis","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Annapolis","region":"Maryland","hidden":false}],"description":"<p>Exciting Opportunity for Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"9409C009FB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9409C009FB","shortlink":"https://apply.workable.com/j/9409C009FB","application_url":"https://apply.workable.com/j/9409C009FB/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our WILMINGTON, DE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"66293E1204","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/66293E1204","shortlink":"https://apply.workable.com/j/66293E1204","application_url":"https://apply.workable.com/j/66293E1204/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our WILMINGTON, DE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"DEE35D30B2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DEE35D30B2","shortlink":"https://apply.workable.com/j/DEE35D30B2","application_url":"https://apply.workable.com/j/DEE35D30B2/apply","published_on":"2023-10-02","created_at":"2023-10-02","country":"United States","city":"Charleston","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charleston","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLESTON, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"E809CE5D55","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E809CE5D55","shortlink":"https://apply.workable.com/j/E809CE5D55","application_url":"https://apply.workable.com/j/E809CE5D55/apply","published_on":"2024-04-29","created_at":"2024-04-29","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"E0DEBD413D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E0DEBD413D","shortlink":"https://apply.workable.com/j/E0DEBD413D","application_url":"https://apply.workable.com/j/E0DEBD413D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"B261D407BA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B261D407BA","shortlink":"https://apply.workable.com/j/B261D407BA","application_url":"https://apply.workable.com/j/B261D407BA/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"8AA84868AC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8AA84868AC","shortlink":"https://apply.workable.com/j/8AA84868AC","application_url":"https://apply.workable.com/j/8AA84868AC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"9A07DD44FE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9A07DD44FE","shortlink":"https://apply.workable.com/j/9A07DD44FE","application_url":"https://apply.workable.com/j/9A07DD44FE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"E19BC1CB78","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E19BC1CB78","shortlink":"https://apply.workable.com/j/E19BC1CB78","application_url":"https://apply.workable.com/j/E19BC1CB78/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"481407118D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/481407118D","shortlink":"https://apply.workable.com/j/481407118D","application_url":"https://apply.workable.com/j/481407118D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"7295A4BA2D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7295A4BA2D","shortlink":"https://apply.workable.com/j/7295A4BA2D","application_url":"https://apply.workable.com/j/7295A4BA2D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"D8188C6C23","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/D8188C6C23","shortlink":"https://apply.workable.com/j/D8188C6C23","application_url":"https://apply.workable.com/j/D8188C6C23/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Asheboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Asheboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"0AE9D9A4B8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0AE9D9A4B8","shortlink":"https://apply.workable.com/j/0AE9D9A4B8","application_url":"https://apply.workable.com/j/0AE9D9A4B8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"5516AF1435","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5516AF1435","shortlink":"https://apply.workable.com/j/5516AF1435","application_url":"https://apply.workable.com/j/5516AF1435/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"37059C3D81","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/37059C3D81","shortlink":"https://apply.workable.com/j/37059C3D81","application_url":"https://apply.workable.com/j/37059C3D81/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"39C4C003AD","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/39C4C003AD","shortlink":"https://apply.workable.com/j/39C4C003AD","application_url":"https://apply.workable.com/j/39C4C003AD/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"5177EA7BFE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5177EA7BFE","shortlink":"https://apply.workable.com/j/5177EA7BFE","application_url":"https://apply.workable.com/j/5177EA7BFE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"3EF298D914","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3EF298D914","shortlink":"https://apply.workable.com/j/3EF298D914","application_url":"https://apply.workable.com/j/3EF298D914/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"8BA7416F08","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8BA7416F08","shortlink":"https://apply.workable.com/j/8BA7416F08","application_url":"https://apply.workable.com/j/8BA7416F08/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"ED10F5174B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/ED10F5174B","shortlink":"https://apply.workable.com/j/ED10F5174B","application_url":"https://apply.workable.com/j/ED10F5174B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"E6DCEFBE2C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E6DCEFBE2C","shortlink":"https://apply.workable.com/j/E6DCEFBE2C","application_url":"https://apply.workable.com/j/E6DCEFBE2C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Monroe","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Monroe","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"220FAFDAF0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/220FAFDAF0","shortlink":"https://apply.workable.com/j/220FAFDAF0","application_url":"https://apply.workable.com/j/220FAFDAF0/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lexington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lexington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"2BA90B9A36","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2BA90B9A36","shortlink":"https://apply.workable.com/j/2BA90B9A36","application_url":"https://apply.workable.com/j/2BA90B9A36/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"CEE1C2005A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CEE1C2005A","shortlink":"https://apply.workable.com/j/CEE1C2005A","application_url":"https://apply.workable.com/j/CEE1C2005A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"AFC93BC188","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AFC93BC188","shortlink":"https://apply.workable.com/j/AFC93BC188","application_url":"https://apply.workable.com/j/AFC93BC188/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"6DF7A90EC1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/6DF7A90EC1","shortlink":"https://apply.workable.com/j/6DF7A90EC1","application_url":"https://apply.workable.com/j/6DF7A90EC1/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Fayetteville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Fayetteville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0CDA1B270B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CDA1B270B","shortlink":"https://apply.workable.com/j/0CDA1B270B","application_url":"https://apply.workable.com/j/0CDA1B270B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"10BABFFCB4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/10BABFFCB4","shortlink":"https://apply.workable.com/j/10BABFFCB4","application_url":"https://apply.workable.com/j/10BABFFCB4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"2DB056769B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2DB056769B","shortlink":"https://apply.workable.com/j/2DB056769B","application_url":"https://apply.workable.com/j/2DB056769B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rocky Mount","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rocky Mount","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"8E9E2FFE5B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8E9E2FFE5B","shortlink":"https://apply.workable.com/j/8E9E2FFE5B","application_url":"https://apply.workable.com/j/8E9E2FFE5B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"F6EECE6D56","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F6EECE6D56","shortlink":"https://apply.workable.com/j/F6EECE6D56","application_url":"https://apply.workable.com/j/F6EECE6D56/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"B57FDA9C64","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B57FDA9C64","shortlink":"https://apply.workable.com/j/B57FDA9C64","application_url":"https://apply.workable.com/j/B57FDA9C64/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"569916377E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/569916377E","shortlink":"https://apply.workable.com/j/569916377E","application_url":"https://apply.workable.com/j/569916377E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"558B3E5F4B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/558B3E5F4B","shortlink":"https://apply.workable.com/j/558B3E5F4B","application_url":"https://apply.workable.com/j/558B3E5F4B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0146117894","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0146117894","shortlink":"https://apply.workable.com/j/0146117894","application_url":"https://apply.workable.com/j/0146117894/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0CE73A1CA1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CE73A1CA1","shortlink":"https://apply.workable.com/j/0CE73A1CA1","application_url":"https://apply.workable.com/j/0CE73A1CA1/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Home Improvement Sales Representative","shortcode":"839DE32659","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/839DE32659","shortlink":"https://apply.workable.com/j/839DE32659","application_url":"https://apply.workable.com/j/839DE32659/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"58C35F73A2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/58C35F73A2","shortlink":"https://apply.workable.com/j/58C35F73A2","application_url":"https://apply.workable.com/j/58C35F73A2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"A3B3E81B4B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A3B3E81B4B","shortlink":"https://apply.workable.com/j/A3B3E81B4B","application_url":"https://apply.workable.com/j/A3B3E81B4B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"464BF35316","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/464BF35316","shortlink":"https://apply.workable.com/j/464BF35316","application_url":"https://apply.workable.com/j/464BF35316/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, your primary responsibility will be to sell roofing products and services to homeowners. This role entails meeting with homeowners, evaluating their roofing requirements, offering recommendations for products and services, and ultimately closing sales. The company will provide qualified leads, so there is no need for cold calling. In this role, your specific tasks will include: </p><ul> <li>Conducting 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Achieving sales targets by closing sales</li> <li>Providing exceptional customer service throughout the sales process</li> <li>Attending trainings and staying up-to-date on company products and services</li> <li>Driving to pre-set appointments; no cold calling or door knocking required</li> <li>Completing a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attending regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul>"},{"title":"Home Improvement Sales Representative","shortcode":"C65E42369E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C65E42369E","shortlink":"https://apply.workable.com/j/C65E42369E","application_url":"https://apply.workable.com/j/C65E42369E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"9761AE0AB3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9761AE0AB3","shortlink":"https://apply.workable.com/j/9761AE0AB3","application_url":"https://apply.workable.com/j/9761AE0AB3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"50C4C85600","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/50C4C85600","shortlink":"https://apply.workable.com/j/50C4C85600","application_url":"https://apply.workable.com/j/50C4C85600/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Inside Sales/Customer Service Representative","shortcode":"A990B43C15","code":"","employment_type":"Full-time","telecommuting":false,"department":"Call Center","url":"https://apply.workable.com/j/A990B43C15","shortlink":"https://apply.workable.com/j/A990B43C15","application_url":"https://apply.workable.com/j/A990B43C15/apply","published_on":"2024-01-03","created_at":"2024-01-03","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Customer Service","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Southern National is seeking an enthusiastic and friendly Inside Sales/Customer Service Representative to join our team! Our professional roofing company focuses on energy-efficient residential roofing replacement, specializing in products and installation methods that cater to the unique climate and building challenges in the southeastern United States. We are certified to install most roofing brands, including North America's top-selling Timberline® roofing shingles by GAF. As an integral part of our team, you will be responsible for providing exceptional customer service to our existing and potential clients.</p><p><br></p> <h3>Responsibilities</h3><ul> <li>Field inbound calls from our field marketing team as well as clients and prospective clients to schedule appointments</li> <li>Daily telephone interaction with our database of customers and prospects</li> <li>Promotion of our eco-friendly products and services to prospective and existing clients</li> <li>Generation of appointments for our outside sales division</li> <li>Ongoing department meetings and training</li> </ul><p><strong>Requirements</strong></p><ul> <li>2+ years of experience in inside sales or customer service.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to handle high-stress situations in a calm and professional manner.</li> <li>Excellent problem-solving and critical-thinking skills.</li> <li>Familiarity with Microsoft Office and CRM systems (Salesforce, Hubspot, etc.).</li> <li>Ability to multitask, prioritize, and manage time effectively.</li> <li>A positive attitude, a thirst for knowledge, and a genuine desire to help customers.</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first year income range: $35,000 - $50,000 (Base Salary plus commission and bonuses)</li> <li>Weekly and monthly opportunities for performance-based rewards</li> <li>Full medical, dental, life and disability insurance</li> <li>Access to the latest technology</li> <li>Unlimited growth opportunity</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"3D7028BFAC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3D7028BFAC","shortlink":"https://apply.workable.com/j/3D7028BFAC","application_url":"https://apply.workable.com/j/3D7028BFAC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"1D3B1AE63B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1D3B1AE63B","shortlink":"https://apply.workable.com/j/1D3B1AE63B","application_url":"https://apply.workable.com/j/1D3B1AE63B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"AEA17B7870","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AEA17B7870","shortlink":"https://apply.workable.com/j/AEA17B7870","application_url":"https://apply.workable.com/j/AEA17B7870/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"BCDDE362E6","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/BCDDE362E6","shortlink":"https://apply.workable.com/j/BCDDE362E6","application_url":"https://apply.workable.com/j/BCDDE362E6/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"872088EAF5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/872088EAF5","shortlink":"https://apply.workable.com/j/872088EAF5","application_url":"https://apply.workable.com/j/872088EAF5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"A75215093C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A75215093C","shortlink":"https://apply.workable.com/j/A75215093C","application_url":"https://apply.workable.com/j/A75215093C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Not Applicable","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Our top 2% roofing company is seeking a Senior Sales Representative to join our team. With multiple locations across multiple states, this is a unique opportunity to join a successful team and grow with our company. In this role, you will be responsible for selling roofing products and services to homeowners. It is important to note that this role does not require cold calling - all leads are provided by the company. As a Senior Sales Representative, your job is to close the sale. We are looking for closers!</p><p>Candidates must live within 45 miles of the office location.</p><p>Extensive paid training is provided, and mandatory, for all hires.</p><p>Key Responsibilities:</p><ul> <li>Meet with homeowners to assess their roofing needs and provide product and service recommendations</li> <li>Close sales and achieve sales targets</li> <li>Collaborate with our team of roofing professionals to develop custom solutions for homeowners</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and product knowledge seminars to stay up-to-date on company products and services</li> </ul><p>This position offers an expected earning of $80,000 - $120,000 per year, with potential for growth and advancement within our company. If you are a driven and experienced sales professional with a passion for providing excellent customer service, and a proven ability to close sales, we want to hear from you.</p><p>Apply today to become our next Senior Sales Representative!</p><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and weekends as needed</li> <li>Valid driver's license and reliable transportation</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"18EBA9B65A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/18EBA9B65A","shortlink":"https://apply.workable.com/j/18EBA9B65A","application_url":"https://apply.workable.com/j/18EBA9B65A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Regional Sales Executive","shortcode":"15D265A62C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/15D265A62C","shortlink":"https://apply.workable.com/j/15D265A62C","application_url":"https://apply.workable.com/j/15D265A62C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"C499FE8EEE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C499FE8EEE","shortlink":"https://apply.workable.com/j/C499FE8EEE","application_url":"https://apply.workable.com/j/C499FE8EEE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"AF22A61836","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AF22A61836","shortlink":"https://apply.workable.com/j/AF22A61836","application_url":"https://apply.workable.com/j/AF22A61836/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"3955A4DB40","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3955A4DB40","shortlink":"https://apply.workable.com/j/3955A4DB40","application_url":"https://apply.workable.com/j/3955A4DB40/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"3253BB167A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3253BB167A","shortlink":"https://apply.workable.com/j/3253BB167A","application_url":"https://apply.workable.com/j/3253BB167A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"DD9508396C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DD9508396C","shortlink":"https://apply.workable.com/j/DD9508396C","application_url":"https://apply.workable.com/j/DD9508396C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"E882D42A06","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E882D42A06","shortlink":"https://apply.workable.com/j/E882D42A06","application_url":"https://apply.workable.com/j/E882D42A06/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"224BB4B6CA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/224BB4B6CA","shortlink":"https://apply.workable.com/j/224BB4B6CA","application_url":"https://apply.workable.com/j/224BB4B6CA/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"7C5F6060E3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7C5F6060E3","shortlink":"https://apply.workable.com/j/7C5F6060E3","application_url":"https://apply.workable.com/j/7C5F6060E3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"EA5ADB0C08","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EA5ADB0C08","shortlink":"https://apply.workable.com/j/EA5ADB0C08","application_url":"https://apply.workable.com/j/EA5ADB0C08/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"99D0A73A3E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/99D0A73A3E","shortlink":"https://apply.workable.com/j/99D0A73A3E","application_url":"https://apply.workable.com/j/99D0A73A3E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"72F7698000","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/72F7698000","shortlink":"https://apply.workable.com/j/72F7698000","application_url":"https://apply.workable.com/j/72F7698000/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"4600E23866","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4600E23866","shortlink":"https://apply.workable.com/j/4600E23866","application_url":"https://apply.workable.com/j/4600E23866/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"B7CD0E6157","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B7CD0E6157","shortlink":"https://apply.workable.com/j/B7CD0E6157","application_url":"https://apply.workable.com/j/B7CD0E6157/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Roofing Sales Representative","shortcode":"0FA552776B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0FA552776B","shortlink":"https://apply.workable.com/j/0FA552776B","application_url":"https://apply.workable.com/j/0FA552776B/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"C4800ABB7A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C4800ABB7A","shortlink":"https://apply.workable.com/j/C4800ABB7A","application_url":"https://apply.workable.com/j/C4800ABB7A/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"C5DF994717","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C5DF994717","shortlink":"https://apply.workable.com/j/C5DF994717","application_url":"https://apply.workable.com/j/C5DF994717/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"D9630B2BA7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/D9630B2BA7","shortlink":"https://apply.workable.com/j/D9630B2BA7","application_url":"https://apply.workable.com/j/D9630B2BA7/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"1EF7CA141C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1EF7CA141C","shortlink":"https://apply.workable.com/j/1EF7CA141C","application_url":"https://apply.workable.com/j/1EF7CA141C/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"B4E8C2D84D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B4E8C2D84D","shortlink":"https://apply.workable.com/j/B4E8C2D84D","application_url":"https://apply.workable.com/j/B4E8C2D84D/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"735C13B256","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/735C13B256","shortlink":"https://apply.workable.com/j/735C13B256","application_url":"https://apply.workable.com/j/735C13B256/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Senior Sales Representative","shortcode":"4A90F1940C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4A90F1940C","shortlink":"https://apply.workable.com/j/4A90F1940C","application_url":"https://apply.workable.com/j/4A90F1940C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"83D57A570A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/83D57A570A","shortlink":"https://apply.workable.com/j/83D57A570A","application_url":"https://apply.workable.com/j/83D57A570A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"F65438B9D2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F65438B9D2","shortlink":"https://apply.workable.com/j/F65438B9D2","application_url":"https://apply.workable.com/j/F65438B9D2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"CABB143C25","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CABB143C25","shortlink":"https://apply.workable.com/j/CABB143C25","application_url":"https://apply.workable.com/j/CABB143C25/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"7CAFFBD8C9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7CAFFBD8C9","shortlink":"https://apply.workable.com/j/7CAFFBD8C9","application_url":"https://apply.workable.com/j/7CAFFBD8C9/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"2AFD4D702A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2AFD4D702A","shortlink":"https://apply.workable.com/j/2AFD4D702A","application_url":"https://apply.workable.com/j/2AFD4D702A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"57B80EB15B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/57B80EB15B","shortlink":"https://apply.workable.com/j/57B80EB15B","application_url":"https://apply.workable.com/j/57B80EB15B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"}]}
-  recorded_at: Mon, 29 Jul 2024 09:14:35 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:32 GMT
 - request:
     method: post
     uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
@@ -277,9 +277,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:14:36 GMT
+      - Tue, 30 Jul 2024 16:26:33 GMT
       Etag:
-      - W/"1722244476160"
+      - W/"1722356793531"
       Server:
       - openresty
       X-Cb-Engine:
@@ -291,11 +291,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '0'
       X-Cb-Engine-Took:
-      - '2'
+      - '3'
       X-Cb-Engine-Total-Count:
       - '0'
       X-Cb-Request-Took:
-      - '15'
+      - '13'
       Content-Length:
       - '25'
       Connection:
@@ -303,7 +303,7 @@ http_interactions:
     body:
       encoding: UTF-8
       string: '{"count":0,"entities":[]}'
-  recorded_at: Mon, 29 Jul 2024 09:14:36 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:33 GMT
 - request:
     method: get
     uri: https://www.workable.com/api/accounts/southern-national?details=true
@@ -323,7 +323,7 @@ http_interactions:
       message: Moved Temporarily
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:36 GMT
+      - Tue, 30 Jul 2024 16:26:33 GMT
       Content-Type:
       - text/html
       Content-Length:
@@ -337,8 +337,8 @@ http_interactions:
       Location:
       - https://apply.workable.com/api/v1/widget/accounts/southern-national?details=true
       Set-Cookie:
-      - __cf_bm=3uprqCNdz_PGB9g_yBP6FubZO12s2Io_AgRle9zwoAU-1722244476-1.0.1.1-osEhBzbJmuLV7JlYBdnf0xL_M5FKIMGbMFObXGPOVvXGAkf74Jp9XgZmX1m63Z37qnwP2HG34v_JIymZ49CC4Q;
-        path=/; expires=Mon, 29-Jul-24 09:44:36 GMT; domain=.workable.com; HttpOnly;
+      - __cf_bm=z8PZeIMljL27oQHhP7MMfCPWQiEUh9HQxiOjt1LRAAQ-1722356793-1.0.1.1-M58oxzEvqPidd0c8cBSw1ZqQSsTXMfjJddbq5Qe7AT6uya2qBvyFtWXwgEMpB5EBYTeytawlZD9YX6ntG53wMg;
+        path=/; expires=Tue, 30-Jul-24 16:56:33 GMT; domain=.workable.com; HttpOnly;
         Secure; SameSite=None
       Vary:
       - Accept-Encoding
@@ -349,16 +349,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors https://*.workable.com/; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabffe8cdc676e1
+      - frame-ancestors https://*.workable.com/; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b6084b72bec8
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabffe8cdc676e1-LHR
+      - 8ab6b6084b72bec8-LHR
     body:
       encoding: UTF-8
       string: "<html>\r\n<head><title>302 Found</title></head>\r\n<body>\r\n<center><h1>302
         Found</h1></center>\r\n<hr><center>cloudflare</center>\r\n</body>\r\n</html>\r\n"
-  recorded_at: Mon, 29 Jul 2024 09:14:36 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:33 GMT
 - request:
     method: get
     uri: https://apply.workable.com/api/v1/widget/accounts/southern-national?details=true
@@ -369,7 +369,7 @@ http_interactions:
       Accept:
       - application/json
       Cookie:
-      - __cf_bm=3uprqCNdz_PGB9g_yBP6FubZO12s2Io_AgRle9zwoAU-1722244476-1.0.1.1-osEhBzbJmuLV7JlYBdnf0xL_M5FKIMGbMFObXGPOVvXGAkf74Jp9XgZmX1m63Z37qnwP2HG34v_JIymZ49CC4Q
+      - __cf_bm=z8PZeIMljL27oQHhP7MMfCPWQiEUh9HQxiOjt1LRAAQ-1722356793-1.0.1.1-M58oxzEvqPidd0c8cBSw1ZqQSsTXMfjJddbq5Qe7AT6uya2qBvyFtWXwgEMpB5EBYTeytawlZD9YX6ntG53wMg
       Accept-Encoding:
       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
       User-Agent:
@@ -380,7 +380,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:36 GMT
+      - Tue, 30 Jul 2024 16:26:33 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -392,8 +392,8 @@ http_interactions:
       Access-Control-Allow-Origin:
       - "*"
       Set-Cookie:
-      - wmc=%7B%22cookie_id%22%3A%229822fcb8-3e38-43c8-95b3-0e141e148ba1%22%7D; path=/;
-        expires=Sat, 29 Jul 2034 21:14:36 GMT; domain=.workable.com; samesite=none;
+      - wmc=%7B%22cookie_id%22%3A%221c4a3ed6-49f7-44d3-b23a-8d20c87c151b%22%7D; path=/;
+        expires=Mon, 31 Jul 2034 04:26:33 GMT; domain=.workable.com; samesite=none;
         secure
       Expect-Ct:
       - enforce, max-age=86400
@@ -414,16 +414,16 @@ http_interactions:
       X-Ts:
       - '0'
       Content-Security-Policy-Report-Only:
-      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8aabffe9180cbd7f
+      - frame-ancestors *; report-uri https://browser-intake-datadoghq.com/api/v2/logs?dd-api-key=pubcbe8d2ef0966e8645a91099cfac490bb&dd-evp-origin=content-security-policy&ddsource=csp-report&ddtags=%40http.headers.cfray%3A8ab6b608dd7cbef5
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabffe9180cbd7f-LHR
+      - 8ab6b608dd7cbef5-LHR
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         {"name":"Southern National Roofing","description":"<p>Southern National Roofing is a professional roofing contractor that focuses on energy-efficient residential roofing replacement, using products and installation methods geared to the unique climate and building challenges in the southeastern United States. We are certified to install most roofing brands including products from GAF, the manufacturer of North America’s #1-selling Timberline® roofing shingles.</p>","jobs":[{"title":"Appointment Setter","shortcode":"7659BE0024","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7659BE0024","shortlink":"https://apply.workable.com/j/7659BE0024","application_url":"https://apply.workable.com/j/7659BE0024/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our WILMINGTON, DE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"E07D9D1957","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E07D9D1957","shortlink":"https://apply.workable.com/j/E07D9D1957","application_url":"https://apply.workable.com/j/E07D9D1957/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our WILMINGTON, DE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"AB7BE627E1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AB7BE627E1","shortlink":"https://apply.workable.com/j/AB7BE627E1","application_url":"https://apply.workable.com/j/AB7BE627E1/apply","published_on":"2023-10-02","created_at":"2023-10-02","country":"United States","city":"Charleston","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charleston","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLESTON, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"41BBB2DBE8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/41BBB2DBE8","shortlink":"https://apply.workable.com/j/41BBB2DBE8","application_url":"https://apply.workable.com/j/41BBB2DBE8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"8DDDAAAA55","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8DDDAAAA55","shortlink":"https://apply.workable.com/j/8DDDAAAA55","application_url":"https://apply.workable.com/j/8DDDAAAA55/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"2248DDE46A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2248DDE46A","shortlink":"https://apply.workable.com/j/2248DDE46A","application_url":"https://apply.workable.com/j/2248DDE46A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"FC1DD2FEAF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/FC1DD2FEAF","shortlink":"https://apply.workable.com/j/FC1DD2FEAF","application_url":"https://apply.workable.com/j/FC1DD2FEAF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"11F35D391A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/11F35D391A","shortlink":"https://apply.workable.com/j/11F35D391A","application_url":"https://apply.workable.com/j/11F35D391A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"1C3EC2297A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1C3EC2297A","shortlink":"https://apply.workable.com/j/1C3EC2297A","application_url":"https://apply.workable.com/j/1C3EC2297A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"F207EEB77B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F207EEB77B","shortlink":"https://apply.workable.com/j/F207EEB77B","application_url":"https://apply.workable.com/j/F207EEB77B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A62C7FFB5A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A62C7FFB5A","shortlink":"https://apply.workable.com/j/A62C7FFB5A","application_url":"https://apply.workable.com/j/A62C7FFB5A/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"25A426104D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/25A426104D","shortlink":"https://apply.workable.com/j/25A426104D","application_url":"https://apply.workable.com/j/25A426104D/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"581F2DF689","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/581F2DF689","shortlink":"https://apply.workable.com/j/581F2DF689","application_url":"https://apply.workable.com/j/581F2DF689/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"944FEC96C0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/944FEC96C0","shortlink":"https://apply.workable.com/j/944FEC96C0","application_url":"https://apply.workable.com/j/944FEC96C0/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our CHARLOTTE office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"8A4756A19F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8A4756A19F","shortlink":"https://apply.workable.com/j/8A4756A19F","application_url":"https://apply.workable.com/j/8A4756A19F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Annapolis","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Annapolis","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"2A241C2A74","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2A241C2A74","shortlink":"https://apply.workable.com/j/2A241C2A74","application_url":"https://apply.workable.com/j/2A241C2A74/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"E43D5A9F14","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E43D5A9F14","shortlink":"https://apply.workable.com/j/E43D5A9F14","application_url":"https://apply.workable.com/j/E43D5A9F14/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"4D05F16C78","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4D05F16C78","shortlink":"https://apply.workable.com/j/4D05F16C78","application_url":"https://apply.workable.com/j/4D05F16C78/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, MARYLAND office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"0C9781DB0B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0C9781DB0B","shortlink":"https://apply.workable.com/j/0C9781DB0B","application_url":"https://apply.workable.com/j/0C9781DB0B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"15258E3B5B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/15258E3B5B","shortlink":"https://apply.workable.com/j/15258E3B5B","application_url":"https://apply.workable.com/j/15258E3B5B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our COLUMBIA, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"17FAD80C09","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/17FAD80C09","shortlink":"https://apply.workable.com/j/17FAD80C09","application_url":"https://apply.workable.com/j/17FAD80C09/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"0A0F60C4F2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0A0F60C4F2","shortlink":"https://apply.workable.com/j/0A0F60C4F2","application_url":"https://apply.workable.com/j/0A0F60C4F2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our GREENSBORO office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"3E59F76FAC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3E59F76FAC","shortlink":"https://apply.workable.com/j/3E59F76FAC","application_url":"https://apply.workable.com/j/3E59F76FAC/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"C7735D4CB9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C7735D4CB9","shortlink":"https://apply.workable.com/j/C7735D4CB9","application_url":"https://apply.workable.com/j/C7735D4CB9/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A8CCE563D7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A8CCE563D7","shortlink":"https://apply.workable.com/j/A8CCE563D7","application_url":"https://apply.workable.com/j/A8CCE563D7/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This appointment setter position requires Daily Travel to our RALEIGH office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p>\\</p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"1A1E53B755","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1A1E53B755","shortlink":"https://apply.workable.com/j/1A1E53B755","application_url":"https://apply.workable.com/j/1A1E53B755/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"A32A8A4288","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A32A8A4288","shortlink":"https://apply.workable.com/j/A32A8A4288","application_url":"https://apply.workable.com/j/A32A8A4288/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our SPARTANBURG, SOUTH CAROLINA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <i>huge </i>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <i>average</i> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time) and some Saturdays</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"62A962AFFF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/62A962AFFF","shortlink":"https://apply.workable.com/j/62A962AFFF","application_url":"https://apply.workable.com/j/62A962AFFF/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"4690BDDD33","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4690BDDD33","shortlink":"https://apply.workable.com/j/4690BDDD33","application_url":"https://apply.workable.com/j/4690BDDD33/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"DB9371FBC2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DB9371FBC2","shortlink":"https://apply.workable.com/j/DB9371FBC2","application_url":"https://apply.workable.com/j/DB9371FBC2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Appointment Setter","shortcode":"CADC40FD39","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CADC40FD39","shortlink":"https://apply.workable.com/j/CADC40FD39","application_url":"https://apply.workable.com/j/CADC40FD39/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $40,000 - $70,000+/year</p><p>This appointment setter position requires Daily Travel to our York, PA office. You will not need to use your personal vehicle for work. There is no overnight travel required.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be working with homeowners to set appointments for our Project Management team to deliver roofing solutions. Your responsibility is not to make any hard sales in the entry level position, but rather to find potential customers and generate appointments with those interested in receiving a free Roofing Estimate.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid marketing training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>Please check us out on Indeed and GlassDoor. We are very proud of our positive culture and the fact that our employees love where they work.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a <em>huge </em>amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul> <li>Perform a detailed roof assessment (from the ground)</li> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> <li>Be responsible for an excellent client experience</li> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $40,000 and 70,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our <em>average</em> pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Appointment Setters average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>You own your own car and have a valid drivers license</li> <li>Ability to work 11am - 7pm M-S (full time) </li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"8708710B12","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8708710B12","shortlink":"https://apply.workable.com/j/8708710B12","application_url":"https://apply.workable.com/j/8708710B12/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Exciting Opportunity for Young Marketing Enthusiasts!</p><p>Are you a young marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2E4E713D75","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2E4E713D75","shortlink":"https://apply.workable.com/j/2E4E713D75","application_url":"https://apply.workable.com/j/2E4E713D75/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity for Young Marketing Enthusiasts!</p><p>Are you a young marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A02BA6B18F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A02BA6B18F","shortlink":"https://apply.workable.com/j/A02BA6B18F","application_url":"https://apply.workable.com/j/A02BA6B18F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"66B9765E1F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/66B9765E1F","shortlink":"https://apply.workable.com/j/66B9765E1F","application_url":"https://apply.workable.com/j/66B9765E1F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"C6ED49CCC5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C6ED49CCC5","shortlink":"https://apply.workable.com/j/C6ED49CCC5","application_url":"https://apply.workable.com/j/C6ED49CCC5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"33D771BD6F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/33D771BD6F","shortlink":"https://apply.workable.com/j/33D771BD6F","application_url":"https://apply.workable.com/j/33D771BD6F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A7ECEBBA42","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A7ECEBBA42","shortlink":"https://apply.workable.com/j/A7ECEBBA42","application_url":"https://apply.workable.com/j/A7ECEBBA42/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"9B3E0AE0F7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9B3E0AE0F7","shortlink":"https://apply.workable.com/j/9B3E0AE0F7","application_url":"https://apply.workable.com/j/9B3E0AE0F7/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"64D4F974C2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/64D4F974C2","shortlink":"https://apply.workable.com/j/64D4F974C2","application_url":"https://apply.workable.com/j/64D4F974C2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2DD07239C2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2DD07239C2","shortlink":"https://apply.workable.com/j/2DD07239C2","application_url":"https://apply.workable.com/j/2DD07239C2/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"3E5C44463A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3E5C44463A","shortlink":"https://apply.workable.com/j/3E5C44463A","application_url":"https://apply.workable.com/j/3E5C44463A/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"EB4BD2DF9C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EB4BD2DF9C","shortlink":"https://apply.workable.com/j/EB4BD2DF9C","application_url":"https://apply.workable.com/j/EB4BD2DF9C/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our CHARLOTTE, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"093D7AD59F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/093D7AD59F","shortlink":"https://apply.workable.com/j/093D7AD59F","application_url":"https://apply.workable.com/j/093D7AD59F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"2176505A35","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2176505A35","shortlink":"https://apply.workable.com/j/2176505A35","application_url":"https://apply.workable.com/j/2176505A35/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office IN COLUMBIA, SOUTH CAROLINA.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"7F5AF2FD27","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7F5AF2FD27","shortlink":"https://apply.workable.com/j/7F5AF2FD27","application_url":"https://apply.workable.com/j/7F5AF2FD27/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"131A4B882F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/131A4B882F","shortlink":"https://apply.workable.com/j/131A4B882F","application_url":"https://apply.workable.com/j/131A4B882F/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our GREENSBORO, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> </ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"69E00CB8BA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/69E00CB8BA","shortlink":"https://apply.workable.com/j/69E00CB8BA","application_url":"https://apply.workable.com/j/69E00CB8BA/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"927846AF02","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/927846AF02","shortlink":"https://apply.workable.com/j/927846AF02","application_url":"https://apply.workable.com/j/927846AF02/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"E4FF1BBBC9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E4FF1BBBC9","shortlink":"https://apply.workable.com/j/E4FF1BBBC9","application_url":"https://apply.workable.com/j/E4FF1BBBC9/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our RALEIGH, NC office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"4FD957F151","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4FD957F151","shortlink":"https://apply.workable.com/j/4FD957F151","application_url":"https://apply.workable.com/j/4FD957F151/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"4E224B9A7C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4E224B9A7C","shortlink":"https://apply.workable.com/j/4E224B9A7C","application_url":"https://apply.workable.com/j/4E224B9A7C/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Marketing Enthusiasts!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul><li>Motivated and confident individuals seeking professional growth in marketing</li></ul><ul><li>High school graduates or GED holders aged 18 and above</li></ul><ul><li>Reliable transportation</li></ul><ul><li>Excellent communication skills to effectively engage with customers</li></ul><ul><li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li></ul><ul><li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li></ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"53BE062C2B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/53BE062C2B","shortlink":"https://apply.workable.com/j/53BE062C2B","application_url":"https://apply.workable.com/j/53BE062C2B/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"0723474365","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0723474365","shortlink":"https://apply.workable.com/j/0723474365","application_url":"https://apply.workable.com/j/0723474365/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"A5519A4680","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A5519A4680","shortlink":"https://apply.workable.com/j/A5519A4680","application_url":"https://apply.workable.com/j/A5519A4680/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Marketing Representative","shortcode":"622803D6DD","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/622803D6DD","shortlink":"https://apply.workable.com/j/622803D6DD","application_url":"https://apply.workable.com/j/622803D6DD/apply","published_on":"2024-07-28","created_at":"2024-07-28","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity!</p><p>Are you a marketing enthusiast looking for an opportunity to kickstart your career? Southern National, an innovative roofing and home improvement company backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to join our dynamic and fast-growing company!</p><p>Why Join Us?</p><p>At Southern National, we believe in nurturing your potential for growth. We provide a clear path for career advancement, starting from an entry-level marketing position and paving the way to managing and senior roles. As our marketing team expands, you'll be an integral part of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level marketing representative, you'll have a crucial role as the first point of contact for our customers. Your primary responsibility will be to engage with clients and promote our top-notch roofing solutions. You'll gain valuable experience through our comprehensive marketing training program, which covers sales strategies, product knowledge, effective communication techniques, and impactful marketing strategies, all designed to set you up for success.</p><p>This position requires daily attendance at our York, PA office.</p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging marketing presentations to clients</li> <li>Participate in daily training meetings to continuously enhance your skills</li> </ul><p>Don't miss out on this exciting opportunity to launch your marketing career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth in marketing</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to effectively engage with customers</li> <li>Availability to work from 11:30 am to 7:30 pm, Monday through Friday, with occasional Saturday availability</li> <li>Professional appearance is a must as our Entry Level Marketing team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Recruiter","shortcode":"11625446FB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Recruiting","url":"https://apply.workable.com/j/11625446FB","shortlink":"https://apply.workable.com/j/11625446FB","application_url":"https://apply.workable.com/j/11625446FB/apply","published_on":"2024-02-23","created_at":"2024-02-23","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Human Resources","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Join Our Team as an Entry Level Recruiter!</p><p>Southern National Roofing is a rapidly growing roofing and home improvement company, and we're seeking motivated individuals to join our HR department as entry-level recruiters. As an entry-level recruiter, you'll play a crucial role in attracting and selecting top talent that aligns with our company's values and goals.</p><p>Why Join Us?</p><p>At Southern National Roofing, we value our employees and their professional growth. As an entry-level recruiter, you'll have the opportunity to learn and grow in a supportive and collaborative environment. We provide comprehensive training and development programs, ensuring that you have the necessary skills and knowledge to excel in your role. Join our team and be part of an exciting journey as we continue to expand and make a difference in the lives of homeowners through our high-quality roofing solutions.</p><p>Key Responsibilities:</p><ul> <li>Assist with sourcing, screening, and selecting candidates for open positions</li> <li>Conduct phone and in-person interviews to assess candidate qualifications</li> <li>Coordinate and schedule interviews with hiring managers</li> <li>Manage the applicant tracking system and maintain accurate candidate records</li> <li>Assist with onboarding new hires and conducting orientation sessions</li> </ul><p></p><p>This position requires daily attendance in our Charlotte, NC office.</p><p><strong>Requirements</strong></p><ul> <li>High school diploma or equivalent</li> <li>Strong communication and interpersonal skills</li> <li>Ability to work with a sense of urgency and meet deadlines</li> <li>Attention to detail and strong organizational skills</li> <li>Proficiency in Microsoft Office Suite</li> <li>Ability to maintain confidentiality and handle sensitive information</li> <li>Prior experience in recruitment or HR is a plus, but not required</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $50,000+ (Base Salary + Commission + Bonuses)</li> <li>Medical and Mental Health Benefits</li> <li>Paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"A5599863A0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A5599863A0","shortlink":"https://apply.workable.com/j/A5599863A0","application_url":"https://apply.workable.com/j/A5599863A0/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"B705ED5163","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B705ED5163","shortlink":"https://apply.workable.com/j/B705ED5163","application_url":"https://apply.workable.com/j/B705ED5163/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"53E26D14D3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/53E26D14D3","shortlink":"https://apply.workable.com/j/53E26D14D3","application_url":"https://apply.workable.com/j/53E26D14D3/apply","published_on":"2024-04-29","created_at":"2024-04-29","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Exciting Opportunity for Young Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"85C117F6B3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/85C117F6B3","shortlink":"https://apply.workable.com/j/85C117F6B3","application_url":"https://apply.workable.com/j/85C117F6B3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"13CFEF8FF3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/13CFEF8FF3","shortlink":"https://apply.workable.com/j/13CFEF8FF3","application_url":"https://apply.workable.com/j/13CFEF8FF3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"8928451BA2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8928451BA2","shortlink":"https://apply.workable.com/j/8928451BA2","application_url":"https://apply.workable.com/j/8928451BA2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"E1585E246E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E1585E246E","shortlink":"https://apply.workable.com/j/E1585E246E","application_url":"https://apply.workable.com/j/E1585E246E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"083A5D36C9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/083A5D36C9","shortlink":"https://apply.workable.com/j/083A5D36C9","application_url":"https://apply.workable.com/j/083A5D36C9/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Monroe","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Monroe","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"13D9050FD4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/13D9050FD4","shortlink":"https://apply.workable.com/j/13D9050FD4","application_url":"https://apply.workable.com/j/13D9050FD4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lexington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lexington","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"B551BB4828","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B551BB4828","shortlink":"https://apply.workable.com/j/B551BB4828","application_url":"https://apply.workable.com/j/B551BB4828/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our CHARLOTTE, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"CD35F1E9F8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CD35F1E9F8","shortlink":"https://apply.workable.com/j/CD35F1E9F8","application_url":"https://apply.workable.com/j/CD35F1E9F8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"4E3244D221","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4E3244D221","shortlink":"https://apply.workable.com/j/4E3244D221","application_url":"https://apply.workable.com/j/4E3244D221/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"0432F47723","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0432F47723","shortlink":"https://apply.workable.com/j/0432F47723","application_url":"https://apply.workable.com/j/0432F47723/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"5542FD5BBF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5542FD5BBF","shortlink":"https://apply.workable.com/j/5542FD5BBF","application_url":"https://apply.workable.com/j/5542FD5BBF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"DB7FEDE601","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DB7FEDE601","shortlink":"https://apply.workable.com/j/DB7FEDE601","application_url":"https://apply.workable.com/j/DB7FEDE601/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"334D7BBB28","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/334D7BBB28","shortlink":"https://apply.workable.com/j/334D7BBB28","application_url":"https://apply.workable.com/j/334D7BBB28/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"EF0C15C19D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EF0C15C19D","shortlink":"https://apply.workable.com/j/EF0C15C19D","application_url":"https://apply.workable.com/j/EF0C15C19D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"4759A849E8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4759A849E8","shortlink":"https://apply.workable.com/j/4759A849E8","application_url":"https://apply.workable.com/j/4759A849E8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Asheboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Asheboro","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"319D2CDFAF","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/319D2CDFAF","shortlink":"https://apply.workable.com/j/319D2CDFAF","application_url":"https://apply.workable.com/j/319D2CDFAF/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our GREENSBORO, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National! </p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation </li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"19499025B5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/19499025B5","shortlink":"https://apply.workable.com/j/19499025B5","application_url":"https://apply.workable.com/j/19499025B5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"C9588F86D4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C9588F86D4","shortlink":"https://apply.workable.com/j/C9588F86D4","application_url":"https://apply.workable.com/j/C9588F86D4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"FD12F1A3AB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/FD12F1A3AB","shortlink":"https://apply.workable.com/j/FD12F1A3AB","application_url":"https://apply.workable.com/j/FD12F1A3AB/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office IN COLUMBIA, SOUTH CAROLINA.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"2356649AF4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2356649AF4","shortlink":"https://apply.workable.com/j/2356649AF4","application_url":"https://apply.workable.com/j/2356649AF4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F72156267A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F72156267A","shortlink":"https://apply.workable.com/j/F72156267A","application_url":"https://apply.workable.com/j/F72156267A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"CD45C95CB3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CD45C95CB3","shortlink":"https://apply.workable.com/j/CD45C95CB3","application_url":"https://apply.workable.com/j/CD45C95CB3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Fayetteville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Fayetteville","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"75560CA15F","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/75560CA15F","shortlink":"https://apply.workable.com/j/75560CA15F","application_url":"https://apply.workable.com/j/75560CA15F/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"3BBED68423","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3BBED68423","shortlink":"https://apply.workable.com/j/3BBED68423","application_url":"https://apply.workable.com/j/3BBED68423/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F0D77C7277","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F0D77C7277","shortlink":"https://apply.workable.com/j/F0D77C7277","application_url":"https://apply.workable.com/j/F0D77C7277/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rocky Mount","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rocky Mount","region":"North Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our RALEIGH, NC office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"7277358208","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7277358208","shortlink":"https://apply.workable.com/j/7277358208","application_url":"https://apply.workable.com/j/7277358208/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"E124EBD0D0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E124EBD0D0","shortlink":"https://apply.workable.com/j/E124EBD0D0","application_url":"https://apply.workable.com/j/E124EBD0D0/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"40F78FA40D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/40F78FA40D","shortlink":"https://apply.workable.com/j/40F78FA40D","application_url":"https://apply.workable.com/j/40F78FA40D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"32BA38FC76","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/32BA38FC76","shortlink":"https://apply.workable.com/j/32BA38FC76","application_url":"https://apply.workable.com/j/32BA38FC76/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"0CA3CDBE73","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CA3CDBE73","shortlink":"https://apply.workable.com/j/0CA3CDBE73","application_url":"https://apply.workable.com/j/0CA3CDBE73/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p></p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"F14C3BCA12","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F14C3BCA12","shortlink":"https://apply.workable.com/j/F14C3BCA12","application_url":"https://apply.workable.com/j/F14C3BCA12/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Exciting Opportunity for Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Entry Level Sales Representative","shortcode":"C8BDCF23EC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C8BDCF23EC","shortlink":"https://apply.workable.com/j/C8BDCF23EC","application_url":"https://apply.workable.com/j/C8BDCF23EC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Annapolis","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Annapolis","region":"Maryland","hidden":false}],"description":"<p>Exciting Opportunity for Sales Enthusiasts!</p><p>Looking for a chance to join a dynamic and fast-growing company? Southern National, an innovative roofing and home improvement company, backed by a highly successful team with almost 30 years of experience, is seeking motivated individuals like you to fuel our expansion!</p><p>Why Join Us?</p><p>At Southern National, we believe in your potential for growth. We're proud to promote from within, offering immense opportunities to fast-track your career from an entry-level sales role to managing and senior positions. As our sales team continues to expand, you'll be at the forefront of our exciting journey!</p><p>What You'll Do</p><p>As an entry-level sales representative, you'll play a crucial role as the first point of contact for our customers. Your main responsibility will be scheduling roofing inspections for clients interested in our top-notch roofing solutions. Don't worry, our comprehensive sales training program is the best in the region! You'll gain in-depth knowledge of sales strategies, product expertise, installation techniques, and impactful marketing strategies, setting you up for success.</p><p>This position requires daily attendance in our COLUMBIA, MD office.<br></p><p>Key Responsibilities:</p><ul> <li>Promote Southern National's eco-friendly, green products and services to prospective and existing clients</li> <li>Deliver engaging sales presentations to clients</li> <li>Attend daily training meetings to continuously improve your skills</li> </ul><p>Don't miss out on this exciting opportunity to kickstart your sales career! Apply today and join our energetic team at Southern National!</p><p><strong>Requirements</strong></p><ul> <li>Motivated and confident individuals seeking professional growth</li> <li>High school graduates or GED holders aged 18 and above</li> <li>Reliable transportation</li> <li>Excellent communication skills to engage with customers effectively</li> <li>Availability to work from 11:30am to 7:30pm, Monday through Friday, and occasionally Saturday availability</li> <li>Professional appearance is a must as our Entry Level Sales team engages with over 90% of our clients. No facial tattoos or piercings, please!</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Non-monetary rewards for high performance, such as, high-end electronics, and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"9409C009FB","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9409C009FB","shortlink":"https://apply.workable.com/j/9409C009FB","application_url":"https://apply.workable.com/j/9409C009FB/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Wilmington","state":"Delaware","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Wilmington","region":"Delaware","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our WILMINGTON, DE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"66293E1204","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/66293E1204","shortlink":"https://apply.workable.com/j/66293E1204","application_url":"https://apply.workable.com/j/66293E1204/apply","published_on":"2023-06-28","created_at":"2023-06-28","country":"United States","city":"Philadelphia","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Philadelphia","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our WILMINGTON, DE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect home</li> <li>Provide our customers peace of mind</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"DEE35D30B2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DEE35D30B2","shortlink":"https://apply.workable.com/j/DEE35D30B2","application_url":"https://apply.workable.com/j/DEE35D30B2/apply","published_on":"2023-10-02","created_at":"2023-10-02","country":"United States","city":"Charleston","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charleston","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLESTON, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"E809CE5D55","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E809CE5D55","shortlink":"https://apply.workable.com/j/E809CE5D55","application_url":"https://apply.workable.com/j/E809CE5D55/apply","published_on":"2024-04-29","created_at":"2024-04-29","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"E0DEBD413D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E0DEBD413D","shortlink":"https://apply.workable.com/j/E0DEBD413D","application_url":"https://apply.workable.com/j/E0DEBD413D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"B261D407BA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B261D407BA","shortlink":"https://apply.workable.com/j/B261D407BA","application_url":"https://apply.workable.com/j/B261D407BA/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lancaster","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lancaster","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"8AA84868AC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8AA84868AC","shortlink":"https://apply.workable.com/j/8AA84868AC","application_url":"https://apply.workable.com/j/8AA84868AC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gettysburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gettysburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"9A07DD44FE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9A07DD44FE","shortlink":"https://apply.workable.com/j/9A07DD44FE","application_url":"https://apply.workable.com/j/9A07DD44FE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Hanover","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Hanover","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"E19BC1CB78","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E19BC1CB78","shortlink":"https://apply.workable.com/j/E19BC1CB78","application_url":"https://apply.workable.com/j/E19BC1CB78/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Harrisburg","state":"Pennsylvania","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Harrisburg","region":"Pennsylvania","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our York, PA office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><em>So you can feel great about what you do!</em></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Field Inspectors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-S (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Average first-year income range: $40,000 - $70,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"481407118D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/481407118D","shortlink":"https://apply.workable.com/j/481407118D","application_url":"https://apply.workable.com/j/481407118D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"7295A4BA2D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7295A4BA2D","shortlink":"https://apply.workable.com/j/7295A4BA2D","application_url":"https://apply.workable.com/j/7295A4BA2D/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Burlington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Burlington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"D8188C6C23","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/D8188C6C23","shortlink":"https://apply.workable.com/j/D8188C6C23","application_url":"https://apply.workable.com/j/D8188C6C23/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Asheboro","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Asheboro","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"0AE9D9A4B8","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0AE9D9A4B8","shortlink":"https://apply.workable.com/j/0AE9D9A4B8","application_url":"https://apply.workable.com/j/0AE9D9A4B8/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Winston-Salem","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Winston-Salem","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our GREENSBORO office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"5516AF1435","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5516AF1435","shortlink":"https://apply.workable.com/j/5516AF1435","application_url":"https://apply.workable.com/j/5516AF1435/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"37059C3D81","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/37059C3D81","shortlink":"https://apply.workable.com/j/37059C3D81","application_url":"https://apply.workable.com/j/37059C3D81/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Sumter","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Sumter","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"39C4C003AD","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/39C4C003AD","shortlink":"https://apply.workable.com/j/39C4C003AD","application_url":"https://apply.workable.com/j/39C4C003AD/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lugoff","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lugoff","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"5177EA7BFE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/5177EA7BFE","shortlink":"https://apply.workable.com/j/5177EA7BFE","application_url":"https://apply.workable.com/j/5177EA7BFE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"3EF298D914","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3EF298D914","shortlink":"https://apply.workable.com/j/3EF298D914","application_url":"https://apply.workable.com/j/3EF298D914/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Concord","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Concord","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"8BA7416F08","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8BA7416F08","shortlink":"https://apply.workable.com/j/8BA7416F08","application_url":"https://apply.workable.com/j/8BA7416F08/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gastonia","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gastonia","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"ED10F5174B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/ED10F5174B","shortlink":"https://apply.workable.com/j/ED10F5174B","application_url":"https://apply.workable.com/j/ED10F5174B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Statesville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Statesville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"E6DCEFBE2C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E6DCEFBE2C","shortlink":"https://apply.workable.com/j/E6DCEFBE2C","application_url":"https://apply.workable.com/j/E6DCEFBE2C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Monroe","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Monroe","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"220FAFDAF0","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/220FAFDAF0","shortlink":"https://apply.workable.com/j/220FAFDAF0","application_url":"https://apply.workable.com/j/220FAFDAF0/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Lexington","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Lexington","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"2BA90B9A36","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2BA90B9A36","shortlink":"https://apply.workable.com/j/2BA90B9A36","application_url":"https://apply.workable.com/j/2BA90B9A36/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rock Hill","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rock Hill","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our CHARLOTTE office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"CEE1C2005A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CEE1C2005A","shortlink":"https://apply.workable.com/j/CEE1C2005A","application_url":"https://apply.workable.com/j/CEE1C2005A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"AFC93BC188","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AFC93BC188","shortlink":"https://apply.workable.com/j/AFC93BC188","application_url":"https://apply.workable.com/j/AFC93BC188/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Knightdale","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Knightdale","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"6DF7A90EC1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/6DF7A90EC1","shortlink":"https://apply.workable.com/j/6DF7A90EC1","application_url":"https://apply.workable.com/j/6DF7A90EC1/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Fayetteville","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Fayetteville","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0CDA1B270B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CDA1B270B","shortlink":"https://apply.workable.com/j/0CDA1B270B","application_url":"https://apply.workable.com/j/0CDA1B270B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Durham","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Durham","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"10BABFFCB4","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/10BABFFCB4","shortlink":"https://apply.workable.com/j/10BABFFCB4","application_url":"https://apply.workable.com/j/10BABFFCB4/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Clayton","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Clayton","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"2DB056769B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2DB056769B","shortlink":"https://apply.workable.com/j/2DB056769B","application_url":"https://apply.workable.com/j/2DB056769B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rocky Mount","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rocky Mount","region":"North Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our RALEIGH office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>Employee discount</li> <li>Health insurance and Mental Health Benefits</li> <li>Robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"8E9E2FFE5B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/8E9E2FFE5B","shortlink":"https://apply.workable.com/j/8E9E2FFE5B","application_url":"https://apply.workable.com/j/8E9E2FFE5B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"F6EECE6D56","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F6EECE6D56","shortlink":"https://apply.workable.com/j/F6EECE6D56","application_url":"https://apply.workable.com/j/F6EECE6D56/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Gaffney","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Gaffney","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"B57FDA9C64","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B57FDA9C64","shortlink":"https://apply.workable.com/j/B57FDA9C64","application_url":"https://apply.workable.com/j/B57FDA9C64/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greenville","state":"South Carolina","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greenville","region":"South Carolina","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our SPARTANBURG, SC office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul> <li>Employee discount</li> <li>Health insurance</li> <li>Vision insurance</li> </ul>"},{"title":"Field Inspector","shortcode":"569916377E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/569916377E","shortlink":"https://apply.workable.com/j/569916377E","application_url":"https://apply.workable.com/j/569916377E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"558B3E5F4B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/558B3E5F4B","shortlink":"https://apply.workable.com/j/558B3E5F4B","application_url":"https://apply.workable.com/j/558B3E5F4B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Reisterstown","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Reisterstown","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0146117894","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0146117894","shortlink":"https://apply.workable.com/j/0146117894","application_url":"https://apply.workable.com/j/0146117894/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Rockville","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Rockville","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Field Inspector","shortcode":"0CE73A1CA1","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0CE73A1CA1","shortlink":"https://apply.workable.com/j/0CE73A1CA1","application_url":"https://apply.workable.com/j/0CE73A1CA1/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Towson","state":"Maryland","education":"High School or equivalent","experience":"Entry level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Towson","region":"Maryland","hidden":false}],"description":"<p>Hiring immediately! Salary/Base + Commission + Bonus + Paid Training $30,000 - $60,000+/year</p><p>This position requires Daily Travel to our COLUMBIA, MARYLAND office.</p><p>No experience required (see \"Paid Training\" below)</p><p>Southern National Roofing is the Largest Retail Roofing Contractor with over $15M in Annual Sales.</p><p>In this role you will be representing the brand in pre-selected territories as you speak with homeowners to set in-home appointments for our Project Management team to deliver roofing solutions.</p><p>Our Field Inspectors engage with prospective customers in a professional and memorable manner to generate enthusiasm for our world-class product line.</p><p>If you are looking to change your trajectory, unlock your potential, and start a career in sales and marketing, this is the job for you!</p><p>We are a Certified Green Roofer and a Certified Roofing Responsibly contractor. That means we are dedicated to sustainable business practices.</p><p>We focus on focus on projects that:</p><ul> <li>Save energy</li> <li>Increase a home's value</li> <li>Protect a home</li> <li>Provide our customers peace of mind.</li> </ul><p><i>So you can feel great about what you do!</i></p><p>Paid Training:</p><p>Our paid training program is a full week of the best training in the industry. Over 80% of our team members bring in multiple clients their first day. We focus heavily on product knowledge, installation knowledge, and marketing/sales in this training program.</p><p>We are in the middle of a major expansion and are looking for confident, motivated individuals to join our team. We promote only from within, meaning there is a huge amount of growth potential from this job to move up quickly into managing and senior sales and marketing roles.</p><p>We will train you to:</p><ul><li>Perform a detailed roof assessment (from the ground)</li></ul><ul> <li>Identify customer needs</li> <li>Accurately communicate technical issues to clients</li> </ul><ul><li>Be responsible for an excellent client experience</li></ul><ul> <li>Manage a seamless hand-off to other departments</li> <li>Create excitement with our customers</li> </ul><p>About the pay:</p><ul> <li>We offer commission, plus weekly and monthly bonuses, ON TOP OF YOUR BASE PAY.</li> <li>You can expect to earn between $30,000 and 60,000 in your first year.</li> <li>Based on real Glassdoor, and Indeed employee reviews, our average pay for this position is over $53,000 (over $27 per hour).</li> <li>Our top Brand Ambassadors average $1,500 per week - this works out to over $34 per hour.</li> </ul><p><br></p><p><strong>Requirements</strong></p><p>What we need from you:</p><ul> <li>A positive attitude</li> <li>A strong desire to succeed</li> <li>A professional appearance</li> <li>Great communications skills</li> <li>High school diploma or GED</li> <li>Reliable transportation to and from our office</li> <li>Ability to work 11am - 7pm M-F (full time)</li> <li>Driver's License (Required)</li> </ul><p><strong>Benefits</strong></p><p>Benefits:</p><ul>  <li>Average first-year income range: $30,000 - $60,000+ (Base Salary + Commission + Bonuses)</li> <li>Recognition and rewards for high performance, including high-end electronics and tickets to concerts and events</li> <li>Medical and Mental Health Benefits</li> <li>Ample paid vacation and holidays</li> <li>Access to the latest technology, such as laptops, smartphones, and tablets</li> <li>A robust social program filled with events and activities</li> </ul>"},{"title":"Home Improvement Sales Representative","shortcode":"839DE32659","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/839DE32659","shortlink":"https://apply.workable.com/j/839DE32659","application_url":"https://apply.workable.com/j/839DE32659/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"58C35F73A2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/58C35F73A2","shortlink":"https://apply.workable.com/j/58C35F73A2","application_url":"https://apply.workable.com/j/58C35F73A2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"A3B3E81B4B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A3B3E81B4B","shortlink":"https://apply.workable.com/j/A3B3E81B4B","application_url":"https://apply.workable.com/j/A3B3E81B4B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"464BF35316","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/464BF35316","shortlink":"https://apply.workable.com/j/464BF35316","application_url":"https://apply.workable.com/j/464BF35316/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, your primary responsibility will be to sell roofing products and services to homeowners. This role entails meeting with homeowners, evaluating their roofing requirements, offering recommendations for products and services, and ultimately closing sales. The company will provide qualified leads, so there is no need for cold calling. In this role, your specific tasks will include: </p><ul> <li>Conducting 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Achieving sales targets by closing sales</li> <li>Providing exceptional customer service throughout the sales process</li> <li>Attending trainings and staying up-to-date on company products and services</li> <li>Driving to pre-set appointments; no cold calling or door knocking required</li> <li>Completing a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attending regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul>"},{"title":"Home Improvement Sales Representative","shortcode":"C65E42369E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C65E42369E","shortlink":"https://apply.workable.com/j/C65E42369E","application_url":"https://apply.workable.com/j/C65E42369E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"9761AE0AB3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/9761AE0AB3","shortlink":"https://apply.workable.com/j/9761AE0AB3","application_url":"https://apply.workable.com/j/9761AE0AB3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Home Improvement Sales Representative","shortcode":"50C4C85600","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/50C4C85600","shortlink":"https://apply.workable.com/j/50C4C85600","application_url":"https://apply.workable.com/j/50C4C85600/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Inside Sales/Customer Service Representative","shortcode":"A990B43C15","code":"","employment_type":"Full-time","telecommuting":false,"department":"Call Center","url":"https://apply.workable.com/j/A990B43C15","shortlink":"https://apply.workable.com/j/A990B43C15","application_url":"https://apply.workable.com/j/A990B43C15/apply","published_on":"2024-01-03","created_at":"2024-01-03","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Entry level","function":"Customer Service","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Southern National is seeking an enthusiastic and friendly Inside Sales/Customer Service Representative to join our team! Our professional roofing company focuses on energy-efficient residential roofing replacement, specializing in products and installation methods that cater to the unique climate and building challenges in the southeastern United States. We are certified to install most roofing brands, including North America's top-selling Timberline® roofing shingles by GAF. As an integral part of our team, you will be responsible for providing exceptional customer service to our existing and potential clients.</p><p><br></p> <h3>Responsibilities</h3><ul> <li>Field inbound calls from our field marketing team as well as clients and prospective clients to schedule appointments</li> <li>Daily telephone interaction with our database of customers and prospects</li> <li>Promotion of our eco-friendly products and services to prospective and existing clients</li> <li>Generation of appointments for our outside sales division</li> <li>Ongoing department meetings and training</li> </ul><p><strong>Requirements</strong></p><ul> <li>2+ years of experience in inside sales or customer service.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to handle high-stress situations in a calm and professional manner.</li> <li>Excellent problem-solving and critical-thinking skills.</li> <li>Familiarity with Microsoft Office and CRM systems (Salesforce, Hubspot, etc.).</li> <li>Ability to multitask, prioritize, and manage time effectively.</li> <li>A positive attitude, a thirst for knowledge, and a genuine desire to help customers.</li> </ul><p><strong>Benefits</strong></p><ul> <li>Average first year income range: $35,000 - $50,000 (Base Salary plus commission and bonuses)</li> <li>Weekly and monthly opportunities for performance-based rewards</li> <li>Full medical, dental, life and disability insurance</li> <li>Access to the latest technology</li> <li>Unlimited growth opportunity</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"3D7028BFAC","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3D7028BFAC","shortlink":"https://apply.workable.com/j/3D7028BFAC","application_url":"https://apply.workable.com/j/3D7028BFAC/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"1D3B1AE63B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1D3B1AE63B","shortlink":"https://apply.workable.com/j/1D3B1AE63B","application_url":"https://apply.workable.com/j/1D3B1AE63B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"AEA17B7870","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AEA17B7870","shortlink":"https://apply.workable.com/j/AEA17B7870","application_url":"https://apply.workable.com/j/AEA17B7870/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"BCDDE362E6","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/BCDDE362E6","shortlink":"https://apply.workable.com/j/BCDDE362E6","application_url":"https://apply.workable.com/j/BCDDE362E6/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"872088EAF5","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/872088EAF5","shortlink":"https://apply.workable.com/j/872088EAF5","application_url":"https://apply.workable.com/j/872088EAF5/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"A75215093C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/A75215093C","shortlink":"https://apply.workable.com/j/A75215093C","application_url":"https://apply.workable.com/j/A75215093C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Not Applicable","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Our top 2% roofing company is seeking a Senior Sales Representative to join our team. With multiple locations across multiple states, this is a unique opportunity to join a successful team and grow with our company. In this role, you will be responsible for selling roofing products and services to homeowners. It is important to note that this role does not require cold calling - all leads are provided by the company. As a Senior Sales Representative, your job is to close the sale. We are looking for closers!</p><p>Candidates must live within 45 miles of the office location.</p><p>Extensive paid training is provided, and mandatory, for all hires.</p><p>Key Responsibilities:</p><ul> <li>Meet with homeowners to assess their roofing needs and provide product and service recommendations</li> <li>Close sales and achieve sales targets</li> <li>Collaborate with our team of roofing professionals to develop custom solutions for homeowners</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and product knowledge seminars to stay up-to-date on company products and services</li> </ul><p>This position offers an expected earning of $80,000 - $120,000 per year, with potential for growth and advancement within our company. If you are a driven and experienced sales professional with a passion for providing excellent customer service, and a proven ability to close sales, we want to hear from you.</p><p>Apply today to become our next Senior Sales Representative!</p><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and weekends as needed</li> <li>Valid driver's license and reliable transportation</li> </ul>"},{"title":"Outside Sales Representative","shortcode":"18EBA9B65A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/18EBA9B65A","shortlink":"https://apply.workable.com/j/18EBA9B65A","application_url":"https://apply.workable.com/j/18EBA9B65A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul> <li>1-3 years of in-home B2C sales experience, preferred not required</li> <li>Proven track record of achieving sales targets</li> <li>Strong communication and interpersonal skills</li> <li>Ability to build rapport and establish trust with customers</li> <li>Flexibility to work evenings and Saturdays</li> <li>Valid driver's license and own reliable transportation</li> <li>Ability to work up to 6 days per week, including mandatory Saturdays</li> <li>Coachable and eager to learn</li> <li>Self-disciplined and money-motivated</li> <li>Proficient in using technology (laptop, mobile device, tablet)</li> <li>Outstanding negotiation and communication skills</li> </ul>"},{"title":"Regional Sales Executive","shortcode":"15D265A62C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/15D265A62C","shortlink":"https://apply.workable.com/j/15D265A62C","application_url":"https://apply.workable.com/j/15D265A62C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"C499FE8EEE","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C499FE8EEE","shortlink":"https://apply.workable.com/j/C499FE8EEE","application_url":"https://apply.workable.com/j/C499FE8EEE/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"AF22A61836","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/AF22A61836","shortlink":"https://apply.workable.com/j/AF22A61836","application_url":"https://apply.workable.com/j/AF22A61836/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"3955A4DB40","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3955A4DB40","shortlink":"https://apply.workable.com/j/3955A4DB40","application_url":"https://apply.workable.com/j/3955A4DB40/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"3253BB167A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/3253BB167A","shortlink":"https://apply.workable.com/j/3253BB167A","application_url":"https://apply.workable.com/j/3253BB167A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"DD9508396C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/DD9508396C","shortlink":"https://apply.workable.com/j/DD9508396C","application_url":"https://apply.workable.com/j/DD9508396C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Regional Sales Executive","shortcode":"E882D42A06","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/E882D42A06","shortlink":"https://apply.workable.com/j/E882D42A06","application_url":"https://apply.workable.com/j/E882D42A06/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Southern National Roofing is seeking seasoned professionals to fill the role of Senior Sales Representative. As the leader in home roof replacements across the East Coast, we offer a lucrative opportunity for experienced sales individuals. Your primary focus will be providing in-home consultations for roofing replacements, leveraging our robust lead generation system. </p><p>With no cold calling required, you can concentrate on what you do best—closing deals. Our comprehensive sales training, overseen by department heads, ensures you're equipped for success. Ideal candidates will possess a professional demeanor, a track record of sales excellence, and the ability to work autonomously or as part of a team. While a degree is preferred, relevant sales experience is paramount. </p><p>Join us in shaping the future of our company, where average first-year earnings range from $120k-$150k, with top performers exceeding $200k. Take the next step in your career journey—apply now.</p><p></p><p>-</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"224BB4B6CA","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/224BB4B6CA","shortlink":"https://apply.workable.com/j/224BB4B6CA","application_url":"https://apply.workable.com/j/224BB4B6CA/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"7C5F6060E3","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7C5F6060E3","shortlink":"https://apply.workable.com/j/7C5F6060E3","application_url":"https://apply.workable.com/j/7C5F6060E3/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"EA5ADB0C08","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/EA5ADB0C08","shortlink":"https://apply.workable.com/j/EA5ADB0C08","application_url":"https://apply.workable.com/j/EA5ADB0C08/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"99D0A73A3E","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/99D0A73A3E","shortlink":"https://apply.workable.com/j/99D0A73A3E","application_url":"https://apply.workable.com/j/99D0A73A3E/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"72F7698000","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/72F7698000","shortlink":"https://apply.workable.com/j/72F7698000","application_url":"https://apply.workable.com/j/72F7698000/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"4600E23866","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4600E23866","shortlink":"https://apply.workable.com/j/4600E23866","application_url":"https://apply.workable.com/j/4600E23866/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Remodeling Sales Consultant","shortcode":"B7CD0E6157","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B7CD0E6157","shortlink":"https://apply.workable.com/j/B7CD0E6157","application_url":"https://apply.workable.com/j/B7CD0E6157/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Hey sales pros, ready to take your career to the next level? Southern National Roofing is on the lookout for Regional Sales Executives to join our growing family-owned business. We're the go-to for home roof replacements from Pennsylvania to South Carolina, and we want you on our team. No cold calling here—just quality leads and a solid sales process.</p><p>As a Regional Sales Executive with us, you'll be at the forefront of our success, tapping into our industry-leading metrics—a staggering 90% sit rate and 50% close rate. Picture this: each day, you'll embark on pre-set, pre-qualified leads, averaging one to two appointments per day. These aren't just any leads—they're homeowners in urgent need of a roof replacement, ready to make a decision within the next 30-60 days. How do we achieve such high conversion rates? Our leads undergo a meticulous qualifying process, ensuring they're primed and ready for your expertise.</p><p>If you're a dependable team player with a sharp sales acumen, let's chat. With average first-year earnings hitting $120k-$150k and top performers soaring over $200k, the rewards are real. Plus, with management and executive roles up for grabs, the sky's the limit. Don't miss out—apply today and let's make it rain... shingles!</p><p><strong>Requirements</strong></p><ul> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Roofing Sales Representative","shortcode":"0FA552776B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/0FA552776B","shortlink":"https://apply.workable.com/j/0FA552776B","application_url":"https://apply.workable.com/j/0FA552776B/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"C4800ABB7A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C4800ABB7A","shortlink":"https://apply.workable.com/j/C4800ABB7A","application_url":"https://apply.workable.com/j/C4800ABB7A/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"C5DF994717","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/C5DF994717","shortlink":"https://apply.workable.com/j/C5DF994717","application_url":"https://apply.workable.com/j/C5DF994717/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"D9630B2BA7","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/D9630B2BA7","shortlink":"https://apply.workable.com/j/D9630B2BA7","application_url":"https://apply.workable.com/j/D9630B2BA7/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"1EF7CA141C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/1EF7CA141C","shortlink":"https://apply.workable.com/j/1EF7CA141C","application_url":"https://apply.workable.com/j/1EF7CA141C/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"B4E8C2D84D","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/B4E8C2D84D","shortlink":"https://apply.workable.com/j/B4E8C2D84D","application_url":"https://apply.workable.com/j/B4E8C2D84D/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Roofing Sales Representative","shortcode":"735C13B256","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/735C13B256","shortlink":"https://apply.workable.com/j/735C13B256","application_url":"https://apply.workable.com/j/735C13B256/apply","published_on":"2024-06-24","created_at":"2024-06-24","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Mid-Senior level","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Money-Motivated Closers Wanted! Earn $150,000 - $250,000 per year.</p><p>Join our top 2% roofing company with multiple locations across multiple states. We are a fast-paced and diverse residential roofing company dedicated to providing high-quality home services with integrity and value. Our success is built on a premier customer experience, and we are expanding our team. This is a unique opportunity for an experienced Senior Sales Representative to contribute to our mission of turning our customer's dreams into reality.</p><p><strong>Responsibilities:</strong></p><p>As a Senior Sales Representative, you will be responsible for selling roofing products and services to homeowners. This role involves meeting with homeowners, assessing their roofing needs, providing product and service recommendations, and ultimately closing sales. </p><p>Leads are qualified and provided by the company, and there is no cold calling required.</p><ul> <li>Conduct 8 - 12 pre-scheduled and confirmed in-home appointments per week</li> <li>Close sales and achieve sales targets</li> <li>Provide exceptional customer service throughout the sales process</li> <li>Attend trainings and stay up-to-date on company products and services</li> <li>Drive to pre-set appointments with no cold calling or door knocking required</li> <li>Complete a thorough PAID two-week training program with our dedicated sales training team as part of our on-boarding process</li> <li>Attend regular sales meetings</li> </ul><p><strong>Compensation:</strong></p><ul> <li>Expected monthly earning of $15,000 - $20,000</li> <li>On Target Annual Earnings: $150,000.00 - $250,000.00 </li> <li>Weekly draw against commission + Progressive Uncapped Commission</li> <li>Bonus opportunities other incentives</li> </ul><p><strong>Schedule:</strong></p><ul> <li>Monday - Friday, appointments are scheduled at 1pm and 6pm; Saturday appointments are at 10am</li> <li>Sales meetings are Monday – Thursday at 11am</li> <li>Work Location: Road Warrior</li> </ul><p><strong>Requirements</strong></p><ul><ul> <li>2 years of prior outside sales experience is mandatory for this position</li> <li>Demonstrated history of successfully meeting sales objectives</li> <li>Demonstrates excellent communication and interpersonal skills</li> <li>Able to establish rapport and foster trust with customers</li> <li>Flexible schedule, including availability on evenings and Saturdays</li> <li>Must possess a valid driver's license and have reliable transportation</li> <li>Ability to work up to 6 days per week, with mandatory Saturdays</li> <li>Open to coaching and eager to acquire new skills</li> <li>Exhibits self-discipline and high motivation for financial success</li> <li>Proficient in utilizing various technologies including laptops, mobile devices, and tablets</li> <li>Exceptional negotiation and communication abilities</li> </ul></ul>"},{"title":"Senior Sales Representative","shortcode":"4A90F1940C","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/4A90F1940C","shortlink":"https://apply.workable.com/j/4A90F1940C","application_url":"https://apply.workable.com/j/4A90F1940C/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Charlotte","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Charlotte","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"83D57A570A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/83D57A570A","shortlink":"https://apply.workable.com/j/83D57A570A","application_url":"https://apply.workable.com/j/83D57A570A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"York","state":"Pennsylvania","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"York","region":"Pennsylvania","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"F65438B9D2","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/F65438B9D2","shortlink":"https://apply.workable.com/j/F65438B9D2","application_url":"https://apply.workable.com/j/F65438B9D2/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Greensboro","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Greensboro","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"CABB143C25","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/CABB143C25","shortlink":"https://apply.workable.com/j/CABB143C25","application_url":"https://apply.workable.com/j/CABB143C25/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"South Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"7CAFFBD8C9","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/7CAFFBD8C9","shortlink":"https://apply.workable.com/j/7CAFFBD8C9","application_url":"https://apply.workable.com/j/7CAFFBD8C9/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Columbia","state":"Maryland","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Columbia","region":"Maryland","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"2AFD4D702A","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/2AFD4D702A","shortlink":"https://apply.workable.com/j/2AFD4D702A","application_url":"https://apply.workable.com/j/2AFD4D702A/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Raleigh","state":"North Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Raleigh","region":"North Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"},{"title":"Senior Sales Representative","shortcode":"57B80EB15B","code":"","employment_type":"Full-time","telecommuting":false,"department":"Sales","url":"https://apply.workable.com/j/57B80EB15B","shortlink":"https://apply.workable.com/j/57B80EB15B","application_url":"https://apply.workable.com/j/57B80EB15B/apply","published_on":"2024-07-07","created_at":"2024-07-07","country":"United States","city":"Spartanburg","state":"South Carolina","education":"High School or equivalent","experience":"Associate","function":"Sales","industry":"Retail","locations":[{"country":"United States","countryCode":"US","city":"Spartanburg","region":"South Carolina","hidden":false}],"description":"<p>Join Southern National Roofing, the leading name in home roof replacements across the East Coast. We're looking for dynamic individuals to join our team as Remodeling Sales Consultants. </p><p>If you're a seasoned sales professional with a knack for sealing the deal, look no further. You'll be armed with quality leads, no cold calling necessary. With average first-year earnings ranging from $120k-$150k and top performers hitting $200k+, the sky's the limit. Plus, with management and executive positions on the horizon, this is more than just a job—it's a career opportunity. Apply now and let's build a brighter future together!</p><p><strong>Requirements</strong></p><ul> <li>Proven track record of success in sales, preferably in a consultative selling environment.</li> <li>Excellent communication and interpersonal skills.</li> <li>Ability to build rapport and trust with customers quickly.</li> <li>Strong negotiation and closing skills.</li> <li>Self-motivated with a results-driven approach.</li> <li>Ability to work autonomously while also collaborating effectively within a team.</li> <li>Professional appearance and demeanor.</li> <li>Bachelor's degree or equivalent experience preferred.</li> <li>No visible face or neck tattoos or piercings.</li> <li>Reliable transportation and willingness to travel within the assigned territory, as needed.</li> <li>Familiarity with CRM software and other sales tools is a plus.</li> <li>Willingness to undergo thorough sales training provided by the company.</li> <li>Valid driver's license and clean driving record.</li> <li>Authorization to work in the United States.</li> </ul><p><strong>Benefits</strong></p><p>-At Southern National Roofing, we're more than just a business—we're a family. Our commitment to integrity, excellence, and teamwork drives everything we do. Join a company where you're not just an employee, but a valued member of the team.</p><p>-With Southern National Roofing's rapid expansion, there's ample room for advancement. Many of our top sales consultants have transitioned into management and executive positions. Your success here is limited only by your ambition.</p><p>-We believe in setting our sales team up for success. That's why we provide extensive training led by industry experts, cutting-edge marketing materials, and dedicated support every step of the way. With us, you'll have all the tools you need to excel.</p><p>-We believe in recognizing and rewarding excellence. As a top sales performer at Southern National Roofing, you'll enjoy competitive compensation, lucrative bonuses, and opportunities to be recognized for your hard work at company-wide events.</p>"}]}
-  recorded_at: Mon, 29 Jul 2024 09:14:36 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:33 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Wilmington,%20Delaware%20United%20States?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -443,7 +443,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:36 GMT
+      - Tue, 30 Jul 2024 16:26:39 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -461,18 +461,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 78d28e55a2b0a3745c0933a2cfd5f652
+      - 7f882046d0fde4a87870badbe6e3b101
       X-Msedge-Ref:
-      - 'Ref A: 2E3FDF8AE03F4A9681B0728AC1F8ED9A Ref B: DB3EDGE2719 Ref C: 2024-07-29T09:14:36Z|Ref
-        SnR: 66a75d7c84c64e1dbc4a7a64326148de'
+      - 'Ref SnR: 66a9143f94e54eadaf998fa7203f6c91|Ref A: 679C3A684AA94D22B98B1459F118492C
+        Ref B: DB3EDGE2514 Ref C: 2024-07-30T16:26:39Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-nntvc, mapsplatform-forwardgeocoder-service-69c675d4f5-c2jd7
+      - mapsplatform-frontend-5989d449fd-wr4h9, mapsplatform-forwardgeocoder-service-69c675d4f5-ghghl
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '69'
+      - '71'
       X-Azure-Ref:
-      - 20240729T091436Z-17cc7bff758s7gf6pf31by528n00000008u0000000003swn
+      - 20240730T162639Z-154b59dbc6dk4hlw0sn6sps1r000000009f000000000692m
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -480,8 +480,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:14:36 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:26:39 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Wilmington?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -501,7 +501,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:36 GMT
+      - Tue, 30 Jul 2024 16:26:39 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -519,18 +519,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - f9dc5eee5ab4eb2c755a3de9b6d7e20b
+      - ec1694d60aa034c7f3b69c6956a292ef
       X-Msedge-Ref:
-      - 'Ref A: 1FC9F399D6774694A17BF4BBC944AA7F Ref B: DB3EDGE1814 Ref C: 2024-07-29T09:14:36Z|Ref
-        SnR: 66a75d7c4dd0476b99ce9765b5466c3a'
+      - 'Ref SnR: 66a9143faa534c7695ceba50501a8351|Ref A: 864471720F9348599EF116560433116D
+        Ref B: DB3EDGE3012 Ref C: 2024-07-30T16:26:39Z'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-l6szp, mapsplatform-forwardgeocoder-service-69c675d4f5-65llh
+      - mapsplatform-frontend-5989d449fd-57vjn, mapsplatform-forwardgeocoder-service-69c675d4f5-zv2qg
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '63'
+      - '73'
       X-Azure-Ref:
-      - 20240729T091436Z-154b59dbc6d5lqv7gb5ha8t1mw00000003r000000001091n
+      - 20240730T162639Z-154b59dbc6dsvkxvhc2pneb8g000000006u000000001b0n3
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -538,8 +538,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:14:36 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:26:39 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/Delaware?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -559,7 +559,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:37 GMT
+      - Tue, 30 Jul 2024 16:26:39 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -577,18 +577,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 2abd59f7c77baab347943fab93d1a0e9
+      - 3e3b2fb8034e7e10539367f5d21e3f0e
       X-Msedge-Ref:
-      - 'Ref A: FA25D3E39A5442E7B10CDC800FE8C641 Ref B: LON212050703009 Ref C: 2024-07-29T09:14:36Z|Ref
-        SnR: 66a75d7c658d43278f8809e5217d8924'
+      - 'Ref A: 4CF6E96E38AA46D887915C27B2F1D092 Ref B: DB3EDGE3116 Ref C: 2024-07-30T16:26:39Z|Ref
+        SnR: 66a9143f07f84e92aa3014775f5bba3f'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-8z5f6, mapsplatform-forwardgeocoder-service-69c675d4f5-wq4qq
+      - mapsplatform-frontend-5989d449fd-dd2gk, mapsplatform-forwardgeocoder-service-69c675d4f5-vdxvd
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '92'
+      - '62'
       X-Azure-Ref:
-      - 20240729T091436Z-17cc7bff758zbmb41069tapu8g0000000660000000007kf1
+      - 20240730T162639Z-154b59dbc6dqd7bqt3uyrqpy7800000009qg000000001z5f
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -596,8 +596,8 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6NSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzM4LjQ0MTEzOTIyMTE5MTQwNiwtNzUuNzg3NjY2MzIwODAwNzgsMzkuODM2MjY5Mzc4NjYyMTEsLTc1LjA0OTMyNDAzNTY0NDUzXSwibmFtZSI6IkRlbGF3YXJlIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlszOS4wMDg3NjIzNiwtNzUuNDY4NjQzMTldfSwiYWRkcmVzcyI6eyJhZG1pbkRpc3RyaWN0IjoiREUiLCJjb3VudHJ5UmVnaW9uIjoiVW5pdGVkIFN0YXRlcyIsImZvcm1hdHRlZEFkZHJlc3MiOiJEZWxhd2FyZSJ9LCJjb25maWRlbmNlIjoiSGlnaCIsImVudGl0eVR5cGUiOiJBZG1pbkRpdmlzaW9uMSIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbMzkuMDA4NzYyMzYsLTc1LjQ2ODY0MzE5XSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19LHsiX190eXBlIjoiTG9jYXRpb246aHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS9zZWFyY2gvbG9jYWwvd3MvcmVzdC92MSIsImJib3giOls0MC4yMjczOTc5MTg3MDExNywtODMuMTI4NjIzOTYyNDAyMzQsNDAuMzM4MjE4Njg4OTY0ODQ0LC04My4wMTI1OTYxMzAzNzExXSwibmFtZSI6IkRlbGF3YXJlLCBPSCIsInBvaW50Ijp7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbNDAuMzAxNDk4NDEsLTgzLjA2NzUzNTRdfSwiYWRkcmVzcyI6eyJhZG1pbkRpc3RyaWN0IjoiT0giLCJhZG1pbkRpc3RyaWN0MiI6IkRlbGF3YXJlIENvdW50eSIsImNvdW50cnlSZWdpb24iOiJVbml0ZWQgU3RhdGVzIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkRlbGF3YXJlLCBPSCIsImxvY2FsaXR5IjoiRGVsYXdhcmUifSwiY29uZmlkZW5jZSI6IkxvdyIsImVudGl0eVR5cGUiOiJQb3B1bGF0ZWRQbGFjZSIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbNDAuMzAxNDk4NDEsLTgzLjA2NzUzNTRdLCJjYWxjdWxhdGlvbk1ldGhvZCI6IlJvb2Z0b3AiLCJ1c2FnZVR5cGVzIjpbIkRpc3BsYXkiXX1dLCJtYXRjaENvZGVzIjpbIkdvb2QiXX0seyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzQwLjgxODEyNjY3ODQ2NjgsLTgzLjYxNDQwMjc3MDk5NjEsNDAuOTA2NTEzMjE0MTExMzMsLTgzLjUxNDczOTk5MDIzNDM4XSwibmFtZSI6IkRlbGF3YXJlLCBPSCIsInBvaW50Ijp7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbNDAuODk5NTk3MTcsLTgzLjU1NjY5NDAzXX0sImFkZHJlc3MiOnsiYWRtaW5EaXN0cmljdCI6Ik9IIiwiYWRtaW5EaXN0cmljdDIiOiJIYW5jb2NrIENvdW50eSIsImNvdW50cnlSZWdpb24iOiJVbml0ZWQgU3RhdGVzIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkRlbGF3YXJlLCBPSCIsImxvY2FsaXR5IjoiRGVsYXdhcmUifSwiY29uZmlkZW5jZSI6IkxvdyIsImVudGl0eVR5cGUiOiJQb3B1bGF0ZWRQbGFjZSIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbNDAuODk5NTk3MTcsLTgzLjU1NjY5NDAzXSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19LHsiX190eXBlIjoiTG9jYXRpb246aHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS9zZWFyY2gvbG9jYWwvd3MvcmVzdC92MSIsImJib3giOls0Mi40Njg3MjcxMTE4MTY0MDYsLTkxLjQ5MDU3NzY5Nzc1MzksNDIuNTU3NDk1MTE3MTg3NSwtOTEuMzcwNzg4NTc0MjE4NzVdLCJuYW1lIjoiRGVsYXdhcmUsIElBIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOls0Mi40ODM5NzA2NCwtOTEuNDU3OTM5MTVdfSwiYWRkcmVzcyI6eyJhZG1pbkRpc3RyaWN0IjoiSUEiLCJhZG1pbkRpc3RyaWN0MiI6IkRlbGF3YXJlIENvdW50eSIsImNvdW50cnlSZWdpb24iOiJVbml0ZWQgU3RhdGVzIiwiZm9ybWF0dGVkQWRkcmVzcyI6IkRlbGF3YXJlLCBJQSIsImxvY2FsaXR5IjoiRGVsYXdhcmUifSwiY29uZmlkZW5jZSI6IkxvdyIsImVudGl0eVR5cGUiOiJQb3B1bGF0ZWRQbGFjZSIsImdlb2NvZGVQb2ludHMiOlt7InR5cGUiOiJQb2ludCIsImNvb3JkaW5hdGVzIjpbNDIuNDgzOTcwNjQsLTkxLjQ1NzkzOTE1XSwiY2FsY3VsYXRpb25NZXRob2QiOiJSb29mdG9wIiwidXNhZ2VUeXBlcyI6WyJEaXNwbGF5Il19XSwibWF0Y2hDb2RlcyI6WyJHb29kIl19LHsiX190eXBlIjoiTG9jYXRpb246aHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS9zZWFyY2gvbG9jYWwvd3MvcmVzdC92MSIsImJib3giOls0MS4xNjA5MTUzNzQ3NTU4NiwtNzUuMDI1MTAwNzA4MDA3ODEsNDEuMjg1NjU1OTc1MzQxOCwtNzQuODM4OTU4NzQwMjM0MzhdLCJuYW1lIjoiRGVsYXdhcmUsIFBBIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOls0MS4yMzcxOTc4OCwtNzQuOTI4MTc2ODhdfSwiYWRkcmVzcyI6eyJhZG1pbkRpc3RyaWN0IjoiUEEiLCJhZG1pbkRpc3RyaWN0MiI6IlBpa2UgQ291bnR5IiwiY291bnRyeVJlZ2lvbiI6IlVuaXRlZCBTdGF0ZXMiLCJmb3JtYXR0ZWRBZGRyZXNzIjoiRGVsYXdhcmUsIFBBIiwibG9jYWxpdHkiOiJEZWxhd2FyZSJ9LCJjb25maWRlbmNlIjoiTG93IiwiZW50aXR5VHlwZSI6IlBvcHVsYXRlZFBsYWNlIiwiZ2VvY29kZVBvaW50cyI6W3sidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOls0MS4yMzcxOTc4OCwtNzQuOTI4MTc2ODhdLCJjYWxjdWxhdGlvbk1ldGhvZCI6IlJvb2Z0b3AiLCJ1c2FnZVR5cGVzIjpbIkRpc3BsYXkiXX1dLCJtYXRjaENvZGVzIjpbIkdvb2QiXX1dfV0sInN0YXR1c0NvZGUiOjIwMCwic3RhdHVzRGVzY3JpcHRpb24iOiJPSyIsInRyYWNlSWQiOiIyYWJkNTlmN2M3N2JhYWIzNDc5NDNmYWI5M2QxYTBlOSJ9
-  recorded_at: Mon, 29 Jul 2024 09:14:37 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:26:39 GMT
 - request:
     method: get
     uri: http://dev.virtualearth.net/REST/v1/Locations/United%20States?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
@@ -617,7 +617,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:37 GMT
+      - Tue, 30 Jul 2024 16:26:39 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
@@ -635,18 +635,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 9da9561ae776034f3e807364078f322d
+      - a0f65082813b75123db0f5b7f1dc9b21
       X-Msedge-Ref:
-      - 'Ref A: 80EF4607444C470DB52EEA54881EF5B6 Ref B: DB3EDGE2906 Ref C: 2024-07-29T09:14:37Z|Ref
-        SnR: 66a75d7d7ec545ae90b0d45c54be062f'
+      - 'Ref A: 5773558AD4B94808938C8CDF31E7FCDE Ref B: DB3EDGE2114 Ref C: 2024-07-30T16:26:39Z|Ref
+        SnR: 66a9143f9d0a423999f49845a896e468'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-ldtnd, mapsplatform-forwardgeocoder-service-69c675d4f5-5qklk
+      - mapsplatform-frontend-5989d449fd-sh7rb, mapsplatform-forwardgeocoder-service-69c675d4f5-c2jd7
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '69'
+      - '64'
       X-Azure-Ref:
-      - 20240729T091437Z-154b59dbc6d5skwk9um5h05e1s00000006z000000000n09d
+      - 20240730T162639Z-17cc7bff758vrp8vr5bbxfz28w00000007mg000000004qeu
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -654,6 +654,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzI1LjE0NjAxMzI1OTg4NzY5NSwtMTI0Ljc5MDc1NjIyNTU4NTk0LDQ5LjM4NDM1NzQ1MjM5MjU4LC02Ni45NzAzOTc5NDkyMTg3NV0sIm5hbWUiOiJVbml0ZWQgU3RhdGVzIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlszOS41MDM1NzA1NiwtOTkuMDE4MzQxMDZdfSwiYWRkcmVzcyI6eyJjb3VudHJ5UmVnaW9uIjoiVW5pdGVkIFN0YXRlcyIsImZvcm1hdHRlZEFkZHJlc3MiOiJVbml0ZWQgU3RhdGVzIn0sImNvbmZpZGVuY2UiOiJIaWdoIiwiZW50aXR5VHlwZSI6IkNvdW50cnlSZWdpb24iLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM5LjUwMzU3MDU2LC05OS4wMTgzNDEwNl0sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfV19XSwic3RhdHVzQ29kZSI6MjAwLCJzdGF0dXNEZXNjcmlwdGlvbiI6Ik9LIiwidHJhY2VJZCI6IjlkYTk1NjFhZTc3NjAzNGYzZTgwNzM2NDA3OGYzMjJkIn0=
-  recorded_at: Mon, 29 Jul 2024 09:14:37 GMT
+        eyJhdXRoZW50aWNhdGlvblJlc3VsdENvZGUiOiJWYWxpZENyZWRlbnRpYWxzIiwiYnJhbmRMb2dvVXJpIjoiaHR0cDovL2Rldi52aXJ0dWFsZWFydGgubmV0L0JyYW5kaW5nL2xvZ29fcG93ZXJlZF9ieS5wbmciLCJjb3B5cmlnaHQiOiJDb3B5cmlnaHQgwqkgMjAyNCBNaWNyb3NvZnQgYW5kIGl0cyBzdXBwbGllcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgQVBJIGNhbm5vdCBiZSBhY2Nlc3NlZCBhbmQgdGhlIGNvbnRlbnQgYW5kIGFueSByZXN1bHRzIG1heSBub3QgYmUgdXNlZCwgcmVwcm9kdWNlZCBvciB0cmFuc21pdHRlZCBpbiBhbnkgbWFubmVyIHdpdGhvdXQgZXhwcmVzcyB3cml0dGVuIHBlcm1pc3Npb24gZnJvbSBNaWNyb3NvZnQgQ29ycG9yYXRpb24uIiwicmVzb3VyY2VTZXRzIjpbeyJlc3RpbWF0ZWRUb3RhbCI6MSwicmVzb3VyY2VzIjpbeyJfX3R5cGUiOiJMb2NhdGlvbjpodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3NlYXJjaC9sb2NhbC93cy9yZXN0L3YxIiwiYmJveCI6WzI1LjE0NjAxMzI1OTg4NzY5NSwtMTI0Ljc5MDc1NjIyNTU4NTk0LDQ5LjM4NDM1NzQ1MjM5MjU4LC02Ni45NzAzOTc5NDkyMTg3NV0sIm5hbWUiOiJVbml0ZWQgU3RhdGVzIiwicG9pbnQiOnsidHlwZSI6IlBvaW50IiwiY29vcmRpbmF0ZXMiOlszOS41MDM1NzA1NiwtOTkuMDE4MzQxMDZdfSwiYWRkcmVzcyI6eyJjb3VudHJ5UmVnaW9uIjoiVW5pdGVkIFN0YXRlcyIsImZvcm1hdHRlZEFkZHJlc3MiOiJVbml0ZWQgU3RhdGVzIn0sImNvbmZpZGVuY2UiOiJIaWdoIiwiZW50aXR5VHlwZSI6IkNvdW50cnlSZWdpb24iLCJnZW9jb2RlUG9pbnRzIjpbeyJ0eXBlIjoiUG9pbnQiLCJjb29yZGluYXRlcyI6WzM5LjUwMzU3MDU2LC05OS4wMTgzNDEwNl0sImNhbGN1bGF0aW9uTWV0aG9kIjoiUm9vZnRvcCIsInVzYWdlVHlwZXMiOlsiRGlzcGxheSJdfV0sIm1hdGNoQ29kZXMiOlsiR29vZCJdfV19XSwic3RhdHVzQ29kZSI6MjAwLCJzdGF0dXNEZXNjcmlwdGlvbiI6Ik9LIiwidHJhY2VJZCI6ImEwZjY1MDgyODEzYjc1MTIzZGIwZjViN2YxZGM5YjIxIn0=
+  recorded_at: Tue, 30 Jul 2024 16:26:39 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/create_job_workday.yml b/spec/fixtures/cassettes/create_job_workday.yml
index ee886600..5d8ac883 100644
--- a/spec/fixtures/cassettes/create_job_workday.yml
+++ b/spec/fixtures/cassettes/create_job_workday.yml
@@ -21,7 +21,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:38 GMT
+      - Tue, 30 Jul 2024 16:26:40 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -35,335 +35,41 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=58d78cd1fda625057b031f9323369cd4a87b7835-instance=vps-prod-ttr48tok.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=36bcca7d8e15d381b4d630207078a394ba0db3a3-instance=vps-prod-f6gja4bv.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=XzUckckDgkhlfC3c_85dIgPzPTkxnXfm.VwocvUMxw8-1722244478-1.0.1.1-P75k.OKMMsv1252rZFkGnOp3rJLxlBbVWu7tCbNIkzX9uYDj5VJvpSPovyS88hiu.Rz30Kr_WT0pX5itSCBHsA;
-        path=/; expires=Mon, 29-Jul-24 09:44:38 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=FIRyTaKKvYb6UnSI2MtId9Ykx6QIx8X5k3Nv1T4roSg-1722356800-1.0.1.1-IUwN0Xw.iC5rKQUQxR4zSwGczi8osF0t9KITQDaolqsVeZwLx_AlcuNuKnJhJ0sNZwvW87UAnNZBu8UY_RtggQ;
+        path=/; expires=Tue, 30-Jul-24 16:56:40 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxfk3Ahavs162PW; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:38 GMT; HttpOnly
-      - _cfuvid=1My0WFX0YMxDiWlp38GaW1WmINwULC3nzqZ5QBQSYvY-1722244478621-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKNFTtNTjdFAZDpBJje71DaKPpHRW; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:40 GMT; HttpOnly
+      - _cfuvid=YE_TgrLPi0CVIamL8xjEcTanCN36XL4zgz0sBEnCyzk-1722356800472-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=ae74b54a-b0af-412c-af70-71d0bea0110c; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=904567818.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=6c0407a7-6fcc-4bae-8bf6-ac1603c2c97a; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=2649529354.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|9c2b8631-a9d0-41f1-a018-f57f4a1b05c7
+      - VPS|085706b5-7d23-4c92-b81f-e43f9cd3a394
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - DYNAMIC
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=INursZmlNl7McHIF5rLPznq9%2FjQEVYJuiPq%2BbZi7emDVlGyXgpJTWwgU%2F8Vg9baZl02%2BfnPApdBa3O5KTSGFknPrlXoskDU00FlqF9Z8YWcY7te57NvouOOfDQGvwfNYKOhYxgKHJJ%2BzZP6%2B6dyPSpxOB5W9ko9Vnw%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=Y941BANBg%2BclLTFyMx4A5Ru6MMjgj4zI%2B3MAXNTb%2BKE4K20Ewa0dZOzmvdmYMrsNT9A5Eii6A%2BbFpWKKsnaTvRKLMTDLVsThPP4m%2BDGf5QK%2BEdVqSsOcjwph%2BtVCLm2%2BOZZui4o1ro0esrg2%2FjAM3lY9rFtklKqKMw%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfff23ba20c7c-EWR
+      - 8ab6b62f4ba48c09-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
-      string: '{"total":621,"jobPostings":[{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby,
-        UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48791","Rugby, UK
-        (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby,
-        UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48793","Rugby, UK
-        (ZUK107)"]},{"title":"Senior Technical Support Engineer (Edesix Mobile Video
-        APAC Region)","externalPath":"/job/Penang-Malaysia/Senior-Technical-Support-Engineer--Edesix-Mobile-Video-APAC-Region-_R48950","locationsText":"Penang,
-        Malaysia","postedOn":"Posted Today","bulletFields":["R48950","Penang, Malaysia
-        (ZMY33)"]},{"title":"Systems Integrations and Tests Engineer","externalPath":"/job/Krakow-Poland/Systems-Integrations-and-Tests-Engineer_R48671","locationsText":"Krakow,
-        Poland","postedOn":"Posted Today","bulletFields":["R48671","Krakow, Poland"]},{"title":"Senior
-        UX Designer","externalPath":"/job/Krakow-Poland/Senior-UX-Designer_R47040-1","locationsText":"Krakow,
-        Poland","postedOn":"Posted Today","bulletFields":["R47040","Krakow, Poland"]},{"title":"Software
-        Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48528","locationsText":"Bangalore,
-        India","postedOn":"Posted Today","bulletFields":["R48528","Bangalore, India
-        (ZIN110)"]},{"title":"Software Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48521","locationsText":"Bangalore,
-        India","postedOn":"Posted Today","bulletFields":["R48521","Bangalore, India
-        (ZIN110)"]},{"title":"SOC Analyst","externalPath":"/job/Schaumburg-IL/SOC-Analyst_R48874","locationsText":"Schaumburg,
-        IL","postedOn":"Posted Yesterday","bulletFields":["R48874","Schaumburg, IL
-        (IL01)"]},{"title":"Technical Triage Supervisor","externalPath":"/job/Reynosa-Mexico/Technical-Triage-Supervisor_R47739","locationsText":"Reynosa,
-        Mexico","postedOn":"Posted 3 Days Ago","bulletFields":["R47739","Reynosa,
-        Mexico (ZMX70)"]},{"title":"Senior Sales Engineer","externalPath":"/job/Pennsylvania-US-Offsite/Senior-Sales-Engineer_R48701","locationsText":"Pennsylvania,
-        US Offsite, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48701","Pennsylvania,
-        US Offsite (PA999)"]},{"title":"Director of Procurement","externalPath":"/job/Greater-Chicago-Area/Director-of-Procurement_R48891","locationsText":"Greater
-        Chicago Area, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48891","Greater
-        Chicago Area"]},{"title":"NOC Agent I","externalPath":"/job/Santiago-Chile/NOC-Agent-I_R48421","locationsText":"Santiago,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48421","Santiago,
-        Chile (ZCE10)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48725","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48725","Calama, Chile
-        (ZCE17)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48730","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48730","Calama, Chile
-        (ZCE17)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48729","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48729","Calama, Chile
-        (ZCE17)"]},{"title":"Portfolio Team Director","externalPath":"/job/Schaumburg-IL/Portfolio-Team-Director_R48414","locationsText":"Schaumburg,
-        IL, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48414","Schaumburg,
-        IL (IL01)"]},{"title":"Project Manager - Northeast Region Software Deployment
-        - US Remote","externalPath":"/job/New-Jersey-Remote-Work/Project-Manager---Northeast-Region-Software-Deployment---US-Remote_R48926","locationsText":"New
-        Jersey Remote Work, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48926","New
-        Jersey Remote Work"]},{"title":"Sales Manager","externalPath":"/job/Colorado-Remote-Work/Sales-Manager_R48640","locationsText":"Colorado
-        Remote Work","postedOn":"Posted 3 Days Ago","bulletFields":["R48640","Colorado
-        Remote Work"]},{"title":"Data Protection, Product Compliance Specialist -
-        Legal Support (US Remote)","externalPath":"/job/Chicago-IL/Data-Protection--Product-Compliance-Specialist---Legal-Support--US-Remote-_R48911-1","locationsText":"Chicago,
-        IL, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48911","Chicago,
-        IL (IL156)"]},{"title":"Quality Software Assurance Engineer","externalPath":"/job/Plantation-FL/Quality-Software-Assurance-Engineer_R48284","locationsText":"Plantation,
-        FL","postedOn":"Posted 3 Days Ago","bulletFields":["R48284","Plantation, FL
-        (FL08)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job
-        Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":294},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":89},{"descriptor":"Service
-        & Support","id":"c2197eea2758408bbbe52d2c04006230","count":81},{"descriptor":"Manufacturing
-        & Supply Chain","id":"5a650a685cb64a0ba694baa053e24bda","count":36},{"descriptor":"Information
-        Technology","id":"c3fc17b768e842e39b7192f0bf4cb0f1","count":32},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":28},{"descriptor":"Professional
-        Services","id":"60d771b675b201093e19718f600171af","count":18},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":17},{"descriptor":"General
-        Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":14},{"descriptor":"Administration
-        & Facilities","id":"0191c22da3ac417c94d450ccdb06a7ed","count":5},{"descriptor":"Legal
-        & Regulatory","id":"4170777a1c914320ad8828c0ec033c53","count":4},{"descriptor":"Human
-        Resources","id":"8e651d1131bc4aad9a089b555adc3975","count":3}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"North
-        America","id":"436f05d7afa343d5a8c9f92ef3e8c71b","count":187},{"descriptor":"Asia
-        Pacific","id":"14bb6aa2c25e4a218b2a3faaa951e44c","count":140},{"descriptor":"Europe
-        Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":116},{"descriptor":"Latin
-        America","id":"d6565dafd0ce4473932b0ce1ce9a0307","count":22}]},{"facetParameter":"timeType123","descriptor":"Time
-        Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":615},{"descriptor":"Part
-        time","id":"43259991a4cc42f1a7570dd5dc911e13","count":6}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":8},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":19},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":24},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":64},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":60},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":5},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":2},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":96},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":9},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Saudi
-        Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Taiwan","id":"a4e08b475d6a4176853c9d1cb9854e02","count":1},{"descriptor":"United
-        Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"United
-        Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":35},{"descriptor":"United
-        States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":227},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"Adelaide,
-        Australia","id":"84a18dcbc0d5453081ff0257c1ddc017","count":1},{"descriptor":"Alabama,
-        US Offsite","id":"bbb70e9710004203b5c0165259b19722","count":1},{"descriptor":"Alabama
-        Remote Work","id":"a2aa2501ee340139269db5448422f90a","count":2},{"descriptor":"Alberta
-        Remote Work","id":"a2aa2501ee3401ebad8800458422350b","count":2},{"descriptor":"Albuquerque,
-        NM (NM06)","id":"726d9bb69ca00184bc0a4eeaae18a9a7","count":2},{"descriptor":"Allen,
-        TX (TX139)","id":"a2aa2501ee340194a7e124312b23666e","count":22},{"descriptor":"Antofagasta,
-        Chile","id":"ff21797042291056c2292e32bd504b2e","count":1},{"descriptor":"Argentina
-        Offsite (ZAR99)","id":"5b4156247dd945009ecdd0815cc32261","count":2},{"descriptor":"Arizona,
-        US Offsite","id":"1427da907f71482e93d2ca9a94f4a721","count":19},{"descriptor":"Arizona
-        Remote Work","id":"a2aa2501ee3401172758a8448422ef0a","count":14},{"descriptor":"Arkansas
-        Remote Work","id":"a2aa2501ee340168512097448422e00a","count":1},{"descriptor":"Atlanta,
-        GA","id":"e6754dd8376744ae8810143cfdbd586b","count":1},{"descriptor":"Austria
-        Offsite (ZAT99)","id":"22cd4ef36d4410e861598876a5d8cdbe","count":2},{"descriptor":"Bangalore,
-        India","id":"dc87e0de602f103e7f08db009e1c78c9","count":54},{"descriptor":"Bangalore,
-        India (ZIN114)","id":"4114a9c5ddc5010679785ea9e8011a38","count":5},{"descriptor":"Bangalore
-        offsite, India","id":"83e4449f1df80133688024551401456f","count":3},{"descriptor":"Bay
-        Shore, NY (NY54)","id":"d879770ce580100165639203abdb0000","count":6},{"descriptor":"Beltsville,
-        MD","id":"ec2584050ebf102fb4ed7d77e3a0219e","count":5},{"descriptor":"Berlin,
-        Germany (ZWG172)","id":"da1bb7b30412011d12861db1754a47e2","count":4},{"descriptor":"Birmingham,
-        AL","id":"37cbf3aa4d9810d6aa793a34d460121d","count":1},{"descriptor":"Bogota,
-        Colombia (ZCL04)","id":"4e4bade28097445dbdf1e9acd5883db8","count":2},{"descriptor":"Brazil
-        Offsite","id":"31e50f098c28482282d16915b1f03b02","count":1},{"descriptor":"Brazil
-        Remote Work","id":"a2aa2501ee3401046547064584223a0b","count":14},{"descriptor":"British
-        Columbia,CAN Offsite","id":"99abf5d326b8405d913f070afd962314","count":2},{"descriptor":"British
-        Columbia Remote Work","id":"a2aa2501ee3401529baefa448422300b","count":2},{"descriptor":"Buenos
-        Aires, Ar - bus cntr (ZAR20)","id":"82f5b0bf5d18014fe0aa2c9b8f01e376","count":2},{"descriptor":"Bulgaria
-        Offsite (ZBU99)","id":"b20e212a792d4ebba04149117d379262","count":3},{"descriptor":"Burswood,
-        Australia","id":"315987c1b99841a2a788d8e7f09c3e85","count":1},{"descriptor":"Cairo,
-        Egypt","id":"27419f4f50f31074bf6d12933928093d","count":1},{"descriptor":"Calama,
-        Chile","id":"5add0ac80d6801f6eb698aeb780d6d24","count":3},{"descriptor":"California
-        Northern, US Offsite","id":"51094660fa0a4ec4b328886f73a854d2","count":5},{"descriptor":"California
-        Northern Remote Work","id":"a2aa2501ee34015666cf5f448422b30a","count":11},{"descriptor":"California
-        Southern, US Offsite","id":"2e27a5a31dfb43d6b1fe21b8f268733c","count":6},{"descriptor":"California
-        Southern Remote Work","id":"a2aa2501ee34016f686b59448422ae0a","count":13},{"descriptor":"Charlotte,
-        NC","id":"09f65edec644100fb96d7a9a30a7de0e","count":1},{"descriptor":"Chicago,
-        IL","id":"56b899ac82d3102ebb10086c343f0eed","count":44},{"descriptor":"Chile
-        Remote Work","id":"a2aa2501ee340133264bcf4484220d0b","count":1},{"descriptor":"Colorado,
-        US Offsite","id":"14ab7340d6e645c1827628a28827563a","count":1},{"descriptor":"Colorado
-        Remote Work","id":"a2aa2501ee34015a1230464484229f0a","count":9},{"descriptor":"Connecticut,
-        US Offsite","id":"399e74c7d2c4436ea401e45369f54a9c","count":3},{"descriptor":"Connecticut
-        Remote Work","id":"a2aa2501ee3401d887c339448422950a","count":2},{"descriptor":"Cork,
-        Ireland","id":"61b9ddf3a0c51000b136358fdbcb0000","count":1},{"descriptor":"Cork,
-        Ireland - Business CNTR (ZEI16)","id":"e8aed7fb96be1000b4bd44c6150c0000","count":29},{"descriptor":"Culver
-        City, CA","id":"f2cb61a1d06a01e3044baadd1f01ba77","count":7},{"descriptor":"Dallas,
-        TX","id":"d0be8406d7eb0108618092b78c8c3d7d","count":3},{"descriptor":"Dallas,
-        TX (TX143)","id":"61b9ddf3a0c51000b1184fb114ed0000","count":1},{"descriptor":"Delaware,
-        US Offsite","id":"fdbba75aa4044c649cf4ddd888004e1e","count":8},{"descriptor":"Delaware
-        Remote Work","id":"a2aa2501ee3401860b4433448422900a","count":5},{"descriptor":"Dubai,
-        UAE","id":"7dda71e222860100aa71137f4c680000","count":2},{"descriptor":"Eagan,
-        MN","id":"45632196659f01ded4d69952ac36dd7a","count":1},{"descriptor":"Edinburgh,
-        UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Elgin,
-        IL","id":"56b899ac82d3102ebe1e9ed8fc6722d7","count":1},{"descriptor":"Farmington
-        Hills, MI (MI17)","id":"da1bb7b3041201d56bf55c9f774a95e3","count":1},{"descriptor":"Florida,
-        US Offsite","id":"024e19ecdef743ea8576fd1f592a479c","count":22},{"descriptor":"Florida
-        Remote Work","id":"a2aa2501ee34015d6ddb26478422fd0c","count":24},{"descriptor":"Fornebu,
-        Norway (ZNO11)","id":"ba927ad987ee01020389e6b494000000","count":1},{"descriptor":"Fort
-        Collins, CO (CO29)","id":"4114a9c5ddc501787dea77fde7019936","count":2},{"descriptor":"Fort
-        Worth, TX (TX135)","id":"731a6d25b4bc01260a2ef4efbe0b4e60","count":2},{"descriptor":"Framingham,
-        MA","id":"442a24924422100157ed1e5a4c5c0000","count":1},{"descriptor":"Fresno,
-        CA (CA180)","id":"4114a9c5ddc501232fd3ac42e7010636","count":2},{"descriptor":"Ft.
-        Lauderdale, FL (FL87)","id":"da5e91a4328101abe15bda8ec823a9bc","count":2},{"descriptor":"Georgia,
-        US Offsite","id":"f1180d181cc140dba59dd0e993a002f1","count":14},{"descriptor":"Georgia
-        Remote Work","id":"a2aa2501ee3401b67a9904478422df0c","count":14},{"descriptor":"Germany
-        Offsite (ZWG99)","id":"5c1aee55369b44a2a5136da8dec8e315","count":6},{"descriptor":"Glasgow,
-        UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Glostrup,
-        Denmark (ZDK02)","id":"27a1c404f5744ae68442996960fe2804","count":3},{"descriptor":"Greater
-        Chicago Area","id":"a2aa2501ee34015128ebf2468422d00c","count":15},{"descriptor":"Greater
-        Dallas Area","id":"a2aa2501ee34013ba7b67b4584229a0b","count":1},{"descriptor":"Greater
-        Krakow Area","id":"a2aa2501ee3401e68a4c96478422610d","count":1},{"descriptor":"Gurgaon,
-        India","id":"d879770ce5801001ba2441f0f8260000","count":4},{"descriptor":"Hemel
-        Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1},{"descriptor":"Ho
-        Chi Minh, Vietnam","id":"04fbb808deef1000aba4980e9ce60000","count":2},{"descriptor":"Ho
-        Chi Minh City, Vietnam (ZVI16)","id":"da5e91a4328101b8bd368cee2324adf1","count":1},{"descriptor":"Idaho
-        Remote Work","id":"a2aa2501ee3401e0c730f9468422d50c","count":2},{"descriptor":"Idstein,
-        Germany (ZWG86)","id":"04a42199937044bbbf6010ed72d1d007","count":2},{"descriptor":"Illinois,
-        US Offsite","id":"037ebcbfd6ee4ad8a96ca2f9ec955366","count":33},{"descriptor":"Illinois
-        Remote Work","id":"a2aa2501ee3401b4149aec468422cb0c","count":28},{"descriptor":"Indiana,
-        US Offsite","id":"86ac456645c1476581ccafcdabd07091","count":10},{"descriptor":"Indianapolis,
-        IN","id":"7f977422e7ba456a98281fb6d502202e","count":1},{"descriptor":"Indiana
-        Remote Work","id":"a2aa2501ee3401181c56e6468422c60c","count":15},{"descriptor":"India
-        Offsite (ZIN99)","id":"801ee26ff10b4e2389d3a9d125e02ae3","count":2},{"descriptor":"Iowa,
-        US Offsite","id":"1787eed6fea6446f9bc1036e9a5962d9","count":1},{"descriptor":"Iowa
-        Remote Work","id":"a2aa2501ee34012b9d0fda468422bc0c","count":7},{"descriptor":"Italy
-        Offsite (ZIT99)","id":"7de50b13083047dfb5400de1b3b32aba","count":1},{"descriptor":"Kansas,
-        US Offsite","id":"061f9780eeaf4ab392eb38562e8635c0","count":4},{"descriptor":"Kansas
-        Remote Work","id":"a2aa2501ee3401a115bcd4468422b70c","count":5},{"descriptor":"Kentucky,
-        US Offsite","id":"5e9d2bcbc1df436db79c28a492f83838","count":2},{"descriptor":"Kentucky
-        Remote Work","id":"a2aa2501ee340110c46bcf468422b20c","count":2},{"descriptor":"Krakow,
-        Poland","id":"cdb6c301cead01c0fd6255fbbe0073b9","count":90},{"descriptor":"Krakow,
-        Poland","id":"30c4e7f824bd4b1a892b4ee4a537c2f7","count":2},{"descriptor":"Krakow,
-        Poland","id":"3cc51f087f9747d5b0b2af9d001b0281","count":1},{"descriptor":"Kuala
-        Lumpur, Malaysia","id":"817fef2f26ad4eec85f3d1f59f67a08c","count":2},{"descriptor":"Lexington,
-        SC (SC07)","id":"da5e91a43281017cec012a9ab8239ba2","count":1},{"descriptor":"Linthicum,
-        MD","id":"c152d08a5f9c104eed32617c8087529c","count":3},{"descriptor":"Lisbon,
-        Portugal","id":"d0be8406d7eb01df5699f9468d8cf97d","count":8},{"descriptor":"Lisbon,
-        Portugal","id":"60d771b675b201dd1b8cf4a90e01c534","count":1},{"descriptor":"Little
-        Rock, AR","id":"9294dc0527c54192b5c8338f762402d1","count":1},{"descriptor":"London,
-        UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":4},{"descriptor":"Los
-        Angeles, CA","id":"75eeec0cd30c4823b7cdbc46c87436e3","count":1},{"descriptor":"Los
-        Angeles, CA","id":"20b991fa96e9475db727dbe3c7df1156","count":1},{"descriptor":"Louisiana
-        Remote Work","id":"a2aa2501ee340134851ac4468422a80c","count":1},{"descriptor":"Madrid,
-        Spain","id":"8cfc0951b3b94bd98139c963eb68ec99","count":2},{"descriptor":"Maine,
-        US Offsite","id":"992c04fd1a9c41d3a6a904ffe0de680c","count":3},{"descriptor":"Maine
-        Remote Work","id":"a2aa2501ee34019d8ee2b74684229e0c","count":5},{"descriptor":"Manitoba
-        Remote Work","id":"a2aa2501ee3401b8f6e9f44484222b0b","count":3},{"descriptor":"Maryland,
-        US Offsite","id":"b83767d4324c46c999f575fd542abd88","count":16},{"descriptor":"Maryland
-        Remote Work","id":"a2aa2501ee3401dbf94bb2468422990c","count":18},{"descriptor":"Massachusetts,
-        US Offsite","id":"ef9ff0866473431aa0807077edea046d","count":18},{"descriptor":"Massachusetts
-        Remote Work","id":"a2aa2501ee340136dff99f4684228a0c","count":12},{"descriptor":"Melbourne,
-        Australia","id":"d7e3ba3b107b442382576d564fcbadfd","count":2},{"descriptor":"Mexico
-        City, Mexico","id":"2b254088ddb54694997bd94b011e140c","count":4},{"descriptor":"Mexico
-        Offsite","id":"5ef0f2a16491016a2dbdefc5034f5d9c","count":1},{"descriptor":"Michigan,
-        US Offsite","id":"4b3514833681469ba0b512c446b25b97","count":10},{"descriptor":"Michigan
-        Remote Work","id":"a2aa2501ee3401621d8898468422830c","count":9},{"descriptor":"Minnesota,
-        US Offsite","id":"efb7395e01e54bde949ac224af8f56a6","count":3},{"descriptor":"Minnesota
-        Remote Work","id":"a2aa2501ee34018daff981468422740c","count":5},{"descriptor":"Mississippi
-        Remote Work","id":"a2aa2501ee340143de0a7c4684226f0c","count":2},{"descriptor":"Missouri,
-        US Offsite","id":"fb75ff372ac14e1b809a1dd53333021e","count":2},{"descriptor":"Missouri
-        Remote Work","id":"a2aa2501ee340123e99d6f468422650c","count":4},{"descriptor":"Montana
-        Remote Work","id":"a2aa2501ee3401c92dfa69468422600c","count":1},{"descriptor":"Morocco
-        Offsite (ZMO99)","id":"13183554e71d4ea3b51cc01fb4310a38","count":1},{"descriptor":"Muscat,
-        Oman","id":"7af2294c87014d38b73cc1f8e8046db2","count":1},{"descriptor":"Nebraska
-        Remote Work","id":"a2aa2501ee3401c3ed27644684225b0c","count":1},{"descriptor":"Nevada,
-        US Offsite","id":"63ba34e24ce44a5d92912e0cadae491c","count":1},{"descriptor":"Nevada
-        Remote Work","id":"a2aa2501ee34015e595a5e468422560c","count":2},{"descriptor":"New
-        Hampshire, US Offsite","id":"0727cec59d1544888ff072b50e96a1c3","count":5},{"descriptor":"New
-        Hampshire Remote Work","id":"a2aa2501ee3401e10a2558468422510c","count":3},{"descriptor":"Newington,
-        VA","id":"a2d68824ae0f4fdfa99ac487376a60c0","count":1},{"descriptor":"New
-        Jersey, US Offsite","id":"dd456a04291641a5b02b5731f3e70d4a","count":9},{"descriptor":"New
-        Jersey Remote Work","id":"a2aa2501ee340154abd2524684224c0c","count":14},{"descriptor":"New
-        Mexico, US Offsite","id":"0bf30a8368014b0e90cd36a3c4d20e1a","count":2},{"descriptor":"New
-        Mexico Remote Work","id":"a2aa2501ee3401cff79a46468422420c","count":3},{"descriptor":"New
-        York, US Offsite","id":"3f76dd361d8b410784ca4fc8dc2421f7","count":8},{"descriptor":"New
-        York Remote Work","id":"a2aa2501ee34015fb0b438468422380c","count":11},{"descriptor":"North
-        Carolina, US Offsite","id":"2080bb98030b4515ba37427d91ff32cc","count":13},{"descriptor":"North
-        Carolina Remote Work","id":"a2aa2501ee34015223b220468422210c","count":15},{"descriptor":"North
-        Dakota, US Offsite","id":"a9996a2fd97f4d3e95a330c9526ec0b3","count":1},{"descriptor":"North
-        Dakota Remote Work","id":"a2aa2501ee3401842df90e468422120c","count":3},{"descriptor":"NSW
-        Offsite, Australia","id":"8e1edfbe285b1063341996ac3138c4ca","count":1},{"descriptor":"Offsite
-        France (ZFR99)","id":"71f31ba331b642f3a3ae05b211a469d1","count":1},{"descriptor":"Ohio,
-        US Offsite","id":"c9f53b4342e94035b77570cfe5599af6","count":15},{"descriptor":"Ohio
-        Remote Work","id":"a2aa2501ee34011ff5ccfc458422030c","count":12},{"descriptor":"Oklahoma,
-        US Offsite","id":"7ceb761aa15d46d7b6c9a6bb4d05c509","count":4},{"descriptor":"Oklahoma
-        Remote Work","id":"a2aa2501ee3401d33bbaf6458422fe0b","count":4},{"descriptor":"ONT39","id":"5c4e189f92a610016f2ffc6e5c630000","count":3},{"descriptor":"Ontario
-        Remote Work","id":"a2aa2501ee340179e5f7e8448422210b","count":10},{"descriptor":"Oregon,
-        US Offsite","id":"746c5cc1f07d48d7837f3db4895a18e7","count":9},{"descriptor":"Oregon
-        Remote Work","id":"a2aa2501ee3401d4d45ff0458422f90b","count":5},{"descriptor":"Orlando,
-        FL","id":"b7c95ddf5a041015a61c88e160676351","count":2},{"descriptor":"Oslo,
-        Norway (ZNO07)","id":"8ef71253a56d4aaf92ff5a5364ccc8ac","count":1},{"descriptor":"Ottawa,
-        Canada","id":"77e555f21e5501db407373e92a70fa79","count":1},{"descriptor":"Parma,
-        OH","id":"9efafca5ae9041f7980582836384f807","count":1},{"descriptor":"Penang,
-        Malaysia","id":"c6d7e2b64f8b107f215186f1d658a224","count":58},{"descriptor":"Penang,
-        Malaysia","id":"8dfc527f8ed44cee87fe36c1afbaf264","count":1},{"descriptor":"Penang,
-        Malaysia","id":"168b0d8a3214463583f95156388faf2d","count":1},{"descriptor":"Pennsylvania,
-        US Offsite","id":"89941ac3741f436ab4e333e49a8fba84","count":16},{"descriptor":"Pennsylvania
-        Remote Work","id":"a2aa2501ee3401fe0c4ed8458422e50b","count":12},{"descriptor":"Plantation,
-        FL","id":"17ba885223814f9ab57dedd1e725b00a","count":8},{"descriptor":"Plantation,
-        FL","id":"d879770ce5801001b9b947c3860f0000","count":1},{"descriptor":"Poland
-        Offsite (ZPL99)","id":"9587715495c14b2b946ee753f5adba22","count":8},{"descriptor":"Portugal
-        Offsite (ZPT99)","id":"22e48e01af704af5acf68a768e1184ed","count":1},{"descriptor":"Puerto
-        Rico Offsite","id":"c35e2c7bf9b1444bb4c00699df114d76","count":1},{"descriptor":"Quebec
-        Remote Work","id":"a2aa2501ee34017ab529dc448422170b","count":6},{"descriptor":"Reynosa,
-        Mexico","id":"2cc4589d2ab01001021366bdbd430000","count":1},{"descriptor":"Rhode
-        Island, US Offsite","id":"75ccaab07ff843b4bb5433ed70cbaff7","count":4},{"descriptor":"Rhode
-        Island Remote Work","id":"a2aa2501ee34018f99a6c6458422d60b","count":1},{"descriptor":"Richardson,
-        TX (TX141)","id":"a1b4b9c5b61b016ad44e1b6108028e25","count":1},{"descriptor":"Richmond,
-        VA","id":"9ea53914b84d01586593035807010e1b","count":1},{"descriptor":"Riyadh,
-        Saudi Arabia","id":"dfff2595c3404fe89fcea0c4a139065c","count":2},{"descriptor":"Romania
-        Offsite (ZRO99)","id":"88268c4ae43b48c1bd5baa7007a31a71","count":1},{"descriptor":"Rugby,
-        UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Sacramento,
-        CA","id":"c4ee93d3538249b29c9fb0bfde3295be","count":1},{"descriptor":"San
-        Mateo, CA","id":"3955e91ab9be1000d6a5f34dfd560000","count":1},{"descriptor":"Santiago,
-        Chile","id":"ff21797042291056c1ed919d43474a6f","count":2},{"descriptor":"Santiago,
-        Chile","id":"ff21797042291056c2a0d44e6f564d8b","count":1},{"descriptor":"Sao
-        Paulo, Brazil","id":"d234454abe5110015dd3a0c5bb570000","count":4},{"descriptor":"Sarasota,
-        FL","id":"279a8a3ddd4d018ef74c6ecba500157e","count":1},{"descriptor":"Saskatchewan
-        Remote Work","id":"a2aa2501ee34019300f5d5448422120b","count":3},{"descriptor":"Schaumburg,
-        IL","id":"5983637b827e4ed097966aa984c7cf6c","count":9},{"descriptor":"Schaumburg,
-        IL","id":"f90bd5bcf3df4205a301db42c4557bdd","count":1},{"descriptor":"Schio,
-        Italy","id":"a66ea95a586801014b0a39c8aa730000","count":1},{"descriptor":"Singapore,
-        Singapore","id":"914a4f61913c10357f56e7fd0de4f904","count":1},{"descriptor":"Singapore,
-        Singapore (ZSG38)","id":"c6d7e2b64f8b107f233884cad328a5a5","count":1},{"descriptor":"Somerville,
-        MA","id":"d0be8406d7eb01197d6786d18c8c617d","count":2},{"descriptor":"South
-        Carolina, US Offsite","id":"4548f2167eca45daaa61d7c4aa7d08da","count":2},{"descriptor":"South
-        Carolina Remote Work","id":"a2aa2501ee3401ac594eb9458422cc0b","count":10},{"descriptor":"South
-        Dakota, US Offsite","id":"520ca850ee1443438ff88ea729c5dc1f","count":1},{"descriptor":"South
-        Dakota Remote Work","id":"a2aa2501ee3401e9b731b3458422c70b","count":2},{"descriptor":"Spain
-        Offsite (ZES99)","id":"301a357729b94516a34e3a61a35c1bb5","count":1},{"descriptor":"St.
-        Petersburg, FL (FL92)","id":"4114a9c5ddc501b041023c10a301a7b6","count":1},{"descriptor":"Sterling,
-        VA","id":"ca833823055501ee67c0d0e6ff01d6ee","count":1},{"descriptor":"St Petersburg,
-        FL","id":"b9d0a434256f01442efa8db524cf8e23","count":1},{"descriptor":"Switzerland
-        Offsite (ZSW99)","id":"bc6c8eecc49e4078ac65cd83165d02c5","count":1},{"descriptor":"Sydney,
-        Australia (ZAS102)","id":"a161ce532f951001110b54a8d1f80000","count":1},{"descriptor":"Taguig,
-        Philippines","id":"c6c7d41a752501ed42def116f4000e0e","count":2},{"descriptor":"Taipei,
-        Taiwan (ZTW27)","id":"d5ae1f500ea90178bf268aa77a2ef6bc","count":1},{"descriptor":"Tennessee,
-        US Offsite","id":"aa9f12002a984c16858ff0b2be54fce4","count":14},{"descriptor":"Tennessee
-        Remote Work","id":"a2aa2501ee3401a15dcfac458422c20b","count":13},{"descriptor":"Texas,
-        US Offsite","id":"7951f208c4a44af291de95d7063ca8ea","count":33},{"descriptor":"Texas
-        Remote Work","id":"a2aa2501ee3401bb3ac08d458422a90b","count":25},{"descriptor":"Tokyo,
-        Japan","id":"8c4c7f50760701262d4b1accf800fb4f","count":1},{"descriptor":"Toronto,
-        Canada (ONT40)","id":"442a249244221001582c47e270eb0000","count":6},{"descriptor":"United
-        Arab Emirates Offsite (ZUA99)","id":"dcc3bd6cdddc4454ad3336c2520953a5","count":1},{"descriptor":"United
-        Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":21},{"descriptor":"Utah,
-        US Offsite","id":"f61b91f41da34642ae840d013eb6ec7d","count":18},{"descriptor":"Utah
-        Remote Work","id":"a2aa2501ee3401463afc6e458422900b","count":10},{"descriptor":"Uxbridge,
-        UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Vancouver,
-        Canada","id":"d0be8406d7eb01e1ef6d1c418c8cf679","count":7},{"descriptor":"Vermont
-        Remote Work","id":"a2aa2501ee3401d6729461458422840b","count":3},{"descriptor":"Versailles,
-        France","id":"7dda71e222860100ab254c24897f0000","count":1},{"descriptor":"Vienna,
-        Austria","id":"46a2113a7c421062bd06fb72dee26f45","count":1},{"descriptor":"Virginia,
-        US Offsite","id":"c6987245ed6b4552b729aa8ca40c084f","count":16},{"descriptor":"Virginia
-        Remote Work","id":"a2aa2501ee3401aefdf55a4584227f0b","count":12},{"descriptor":"Ware,
-        UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Warsaw,
-        Poland","id":"d4e8b75046371067ca56ac231068e8e9","count":2},{"descriptor":"Warsaw,
-        Poland","id":"c3422e7a11fd466e8a10d70edc3171ce","count":2},{"descriptor":"Washington,
-        US Offsite","id":"0270f0ddaa9c4df780efe79b9477a4dc","count":5},{"descriptor":"Washington
-        DC, US Offsite","id":"6703b0349e294f7982d1105b4180e6bf","count":4},{"descriptor":"Washington
-        DC Remote Work","id":"a2aa2501ee34012ca4a4274484228b0a","count":6},{"descriptor":"Washington
-        Remote Work","id":"a2aa2501ee3401c3bf02344584225d0b","count":9},{"descriptor":"Westminster,
-        CO","id":"435c641825b8436a950f0c3c604cc62e","count":1},{"descriptor":"West
-        Valley City, UT","id":"dc4b44bb9c9210367f2102c8f37b8c34","count":1},{"descriptor":"West
-        Virginia, US Offsite","id":"41c94f5726b54db19a40ed8ab4c7016f","count":1},{"descriptor":"West
-        Virginia Remote Work","id":"a2aa2501ee3401a5c1d62d458422580b","count":3},{"descriptor":"Wisconsin,
-        US Offsite","id":"e350deb449e548d7be5c7185f399be05","count":2},{"descriptor":"Wisconsin
-        Remote Work","id":"a2aa2501ee340159152027458422530b","count":10},{"descriptor":"Woodcliff
-        Lake, NJ","id":"56b899ac82d3102ebddb9e5d99cf2205","count":1},{"descriptor":"Wyoming,
-        US Offsite","id":"857b68215cb8413f8fc0085cc2df67b3","count":1},{"descriptor":"Wyoming
-        Remote Work","id":"a2aa2501ee3401412f02214584224e0b","count":4},{"descriptor":"ZAS100","id":"20a50c646bd31001a8ec21fd6d5f0000","count":2}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10
-        miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25
-        miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50
-        miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100
-        miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any
-        Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}'
-  recorded_at: Mon, 29 Jul 2024 09:14:38 GMT
+      string: !binary |-
+        {"total":622,"jobPostings":[{"title":"Business and Data Analytics - 2024 Fall Co-Op","externalPath":"/job/Allen-TX-TX139/Business-and-Data-Analytics---2024-Fall-Co-Op_R48967","locationsText":"Allen, TX (TX139)","postedOn":"Posted Today","bulletFields":["R48967","Allen, TX (TX139)"]},{"title":"Channel Sales Executive - Video Security & Access Control (Dallas)","externalPath":"/job/Dallas-TX/Channel-Sales-Executive---Video-Security---Access-Control--Dallas-_R48932","locationsText":"Dallas, TX, More...","postedOn":"Posted Today","bulletFields":["R48932","Dallas, TX (TX133)"]},{"title":"VS&A Product Sales Specialist - Pelco (Southeast)","externalPath":"/job/Ft-Lauderdale-FL-FL87/VS-A-Product-Sales-Specialist---Pelco--Southeast-_R48680-1","locationsText":"Ft. Lauderdale, FL (FL87), More...","postedOn":"Posted Today","bulletFields":["R48680","Ft. Lauderdale, FL (FL87)"]},{"title":"VS&A Product Sales Specialist - Pelco (Northeast)","externalPath":"/job/Framingham-MA/VS-A-Product-Sales-Specialist---Pelco--Northeast-_R48679-1","locationsText":"Framingham, MA, More...","postedOn":"Posted Today","bulletFields":["R48679","Framingham, MA (MA52)"]},{"title":"VS&A Product Sales Specialist - Pelco (West)","externalPath":"/job/Phoenix-AZ/VS-A-Product-Sales-Specialist---Pelco--West-_R48678-1","locationsText":"Phoenix, AZ, More...","postedOn":"Posted Today","bulletFields":["R48678","Phoenix, AZ (AZ93)"]},{"title":"VS&A Product Sales Specialist - Pelco (Central)","externalPath":"/job/Illinois-US-Offsite/VS-A-Product-Sales-Specialist---Pelco--Central-_R48677-1","locationsText":"Illinois, US Offsite, More...","postedOn":"Posted Today","bulletFields":["R48677","Illinois, US Offsite (IL999)"]},{"title":"Software Developer","externalPath":"/job/Bangalore-offsite-India/Software-Developer_R48966","locationsText":"Bangalore offsite, India","postedOn":"Posted Today","bulletFields":["R48966","Bangalore offsite, India (ZIN125)"]},{"title":"Avigilon Business Development Manager, A&E , West Region","externalPath":"/job/California-Northern-Remote-Work/Avigilon-Business-Development-Manager--A-E---West-Region_R48885","locationsText":"California Northern Remote Work, More...","postedOn":"Posted Today","bulletFields":["R48885","California Northern Remote Work"]},{"title":"Junior Order Management Coordinator (mixed shift)","externalPath":"/job/Krakow-Poland/Junior-Order-Management-Coordinator--mixed-shift-_R48896","locationsText":"Krakow, Poland","postedOn":"Posted Today","bulletFields":["R48896","Krakow, Poland"]},{"title":"Responsable support client / Customer Support Manager","externalPath":"/job/Versailles-France/Customer-Support-Manager_R48390","locationsText":"Versailles, France","postedOn":"Posted Today","bulletFields":["R48390","Versailles, France (ZFR49)"]},{"title":"Solutions Architect (US REMOTE)","externalPath":"/job/Colorado-Remote-Work/Sr-Solutions-Architect--US-REMOTE-_R48655","locationsText":"Colorado Remote Work, More...","postedOn":"Posted Today","bulletFields":["R48655","Colorado Remote Work"]},{"title":"Manager Software Engineering","externalPath":"/job/Bangalore-India/Manager-Software-Engineering_R47328","locationsText":"Bangalore, India","postedOn":"Posted Today","bulletFields":["R47328","Bangalore, India (ZIN110)"]},{"title":"Estágio em Gerenciamento de Projetos","externalPath":"/job/Sao-Paulo-Brazil/Estgio-em-Gerenciamento-de-Projetos_R48964","locationsText":"Sao Paulo, Brazil","postedOn":"Posted Today","bulletFields":["R48964","Sao Paulo, Brazil (ZBR48)"]},{"title":"Junior Systems Engineer","externalPath":"/job/Lisbon-Portugal/Junior-Systems-Engineer_R48482","locationsText":"Lisbon, Portugal","postedOn":"Posted Today","bulletFields":["R48482","Lisbon, Portugal (ZPT16)"]},{"title":"Software Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48827","locationsText":"Bangalore, India","postedOn":"Posted Today","bulletFields":["R48827","Bangalore, India (ZIN110)"]},{"title":"Senior Electrical Engineer (RF)","externalPath":"/job/Penang-Malaysia/Senior-Electrical-Engineer--RF-_R45891","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R45891","Penang, Malaysia (ZMY33)"]},{"title":"Software Engineer","externalPath":"/job/Penang-Malaysia/Software-Engineer_R48238","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R48238","Penang, Malaysia (ZMY33)"]},{"title":"Quality Specialist","externalPath":"/job/ZAS100/Quality-Specialist_R46952-1","locationsText":"ZAS100","postedOn":"Posted Today","bulletFields":["R46952","Perth, Australia (ZAS100)"]},{"title":"Senior Field Service Support Engineer","externalPath":"/job/Seoul-Korea/Senior-Field-Service-Support-Engineer_R48271","locationsText":"Seoul, Korea","postedOn":"Posted Today","bulletFields":["R48271","Seoul, Korea (ZKR44)"]},{"title":"Software Engineer","externalPath":"/job/Penang-Malaysia/Software-Engineer_R48236","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R48236","Penang, Malaysia (ZMY33)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":290},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":92},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":84},{"descriptor":"Manufacturing & Supply Chain","id":"5a650a685cb64a0ba694baa053e24bda","count":36},{"descriptor":"Information Technology","id":"c3fc17b768e842e39b7192f0bf4cb0f1","count":29},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":28},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":20},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":18},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":13},{"descriptor":"Administration & Facilities","id":"0191c22da3ac417c94d450ccdb06a7ed","count":6},{"descriptor":"Legal & Regulatory","id":"4170777a1c914320ad8828c0ec033c53","count":3},{"descriptor":"Human Resources","id":"8e651d1131bc4aad9a089b555adc3975","count":3}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"North America","id":"436f05d7afa343d5a8c9f92ef3e8c71b","count":195},{"descriptor":"Asia Pacific","id":"14bb6aa2c25e4a218b2a3faaa951e44c","count":131},{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":117},{"descriptor":"Latin America","id":"d6565dafd0ce4473932b0ce1ce9a0307","count":24}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":613},{"descriptor":"Part time","id":"43259991a4cc42f1a7570dd5dc911e13","count":9}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":5},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":21},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":23},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":61},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1},{"descriptor":"Korea, Republic of","id":"7a5a2aadf9d34086a2bfbfd408bc28da","count":1},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":58},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":6},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":1},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":94},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":10},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":34},{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":236},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"Alabama, US Offsite","id":"bbb70e9710004203b5c0165259b19722","count":1},{"descriptor":"Alabama Remote Work","id":"a2aa2501ee340139269db5448422f90a","count":1},{"descriptor":"Alberta Remote Work","id":"a2aa2501ee3401ebad8800458422350b","count":2},{"descriptor":"Albuquerque, NM (NM06)","id":"726d9bb69ca00184bc0a4eeaae18a9a7","count":2},{"descriptor":"Allen, TX (TX139)","id":"a2aa2501ee340194a7e124312b23666e","count":22},{"descriptor":"Antofagasta, Chile","id":"ff21797042291056c2292e32bd504b2e","count":1},{"descriptor":"Argentina Offsite (ZAR99)","id":"5b4156247dd945009ecdd0815cc32261","count":2},{"descriptor":"Arizona, US Offsite","id":"1427da907f71482e93d2ca9a94f4a721","count":20},{"descriptor":"Arizona Remote Work","id":"a2aa2501ee3401172758a8448422ef0a","count":14},{"descriptor":"Arkansas Remote Work","id":"a2aa2501ee340168512097448422e00a","count":2},{"descriptor":"Atlanta, GA","id":"e6754dd8376744ae8810143cfdbd586b","count":1},{"descriptor":"Austria Offsite (ZAT99)","id":"22cd4ef36d4410e861598876a5d8cdbe","count":2},{"descriptor":"Bangalore, India","id":"dc87e0de602f103e7f08db009e1c78c9","count":50},{"descriptor":"Bangalore, India (ZIN114)","id":"4114a9c5ddc5010679785ea9e8011a38","count":5},{"descriptor":"Bangalore offsite, India","id":"83e4449f1df80133688024551401456f","count":4},{"descriptor":"Bay Shore, NY (NY54)","id":"d879770ce580100165639203abdb0000","count":6},{"descriptor":"Beltsville, MD","id":"ec2584050ebf102fb4ed7d77e3a0219e","count":5},{"descriptor":"Berlin, Germany (ZWG172)","id":"da1bb7b30412011d12861db1754a47e2","count":4},{"descriptor":"Birmingham, AL","id":"37cbf3aa4d9810d6aa793a34d460121d","count":1},{"descriptor":"Bogota, Colombia (ZCL04)","id":"4e4bade28097445dbdf1e9acd5883db8","count":2},{"descriptor":"Brazil Offsite","id":"31e50f098c28482282d16915b1f03b02","count":1},{"descriptor":"Brazil Remote Work","id":"a2aa2501ee3401046547064584223a0b","count":15},{"descriptor":"British Columbia,CAN Offsite","id":"99abf5d326b8405d913f070afd962314","count":2},{"descriptor":"British Columbia Remote Work","id":"a2aa2501ee3401529baefa448422300b","count":2},{"descriptor":"Buenos Aires, Ar - bus cntr (ZAR20)","id":"82f5b0bf5d18014fe0aa2c9b8f01e376","count":2},{"descriptor":"Bulgaria Offsite (ZBU99)","id":"b20e212a792d4ebba04149117d379262","count":3},{"descriptor":"Cairo, Egypt","id":"27419f4f50f31074bf6d12933928093d","count":1},{"descriptor":"Calama, Chile","id":"5add0ac80d6801f6eb698aeb780d6d24","count":3},{"descriptor":"California Northern, US Offsite","id":"51094660fa0a4ec4b328886f73a854d2","count":5},{"descriptor":"California Northern Remote Work","id":"a2aa2501ee34015666cf5f448422b30a","count":12},{"descriptor":"California Southern, US Offsite","id":"2e27a5a31dfb43d6b1fe21b8f268733c","count":6},{"descriptor":"California Southern Remote Work","id":"a2aa2501ee34016f686b59448422ae0a","count":13},{"descriptor":"Charlotte, NC","id":"09f65edec644100fb96d7a9a30a7de0e","count":1},{"descriptor":"Chicago, IL","id":"56b899ac82d3102ebb10086c343f0eed","count":45},{"descriptor":"Chile Remote Work","id":"a2aa2501ee340133264bcf4484220d0b","count":1},{"descriptor":"Colorado, US Offsite","id":"14ab7340d6e645c1827628a28827563a","count":1},{"descriptor":"Colorado Remote Work","id":"a2aa2501ee34015a1230464484229f0a","count":8},{"descriptor":"Connecticut, US Offsite","id":"399e74c7d2c4436ea401e45369f54a9c","count":3},{"descriptor":"Connecticut Remote Work","id":"a2aa2501ee3401d887c339448422950a","count":2},{"descriptor":"Cork, Ireland","id":"61b9ddf3a0c51000b136358fdbcb0000","count":1},{"descriptor":"Cork, Ireland - Business CNTR (ZEI16)","id":"e8aed7fb96be1000b4bd44c6150c0000","count":29},{"descriptor":"Culver City, CA","id":"f2cb61a1d06a01e3044baadd1f01ba77","count":7},{"descriptor":"Dallas, TX","id":"d0be8406d7eb0108618092b78c8c3d7d","count":4},{"descriptor":"Dallas, TX (TX143)","id":"61b9ddf3a0c51000b1184fb114ed0000","count":1},{"descriptor":"Delaware, US Offsite","id":"fdbba75aa4044c649cf4ddd888004e1e","count":8},{"descriptor":"Delaware Remote Work","id":"a2aa2501ee3401860b4433448422900a","count":5},{"descriptor":"Dubai, UAE","id":"7dda71e222860100aa71137f4c680000","count":2},{"descriptor":"Eagan, MN","id":"45632196659f01ded4d69952ac36dd7a","count":1},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Elgin, IL","id":"56b899ac82d3102ebe1e9ed8fc6722d7","count":1},{"descriptor":"Farmington Hills, MI (MI17)","id":"da1bb7b3041201d56bf55c9f774a95e3","count":1},{"descriptor":"Florida, US Offsite","id":"024e19ecdef743ea8576fd1f592a479c","count":23},{"descriptor":"Florida Remote Work","id":"a2aa2501ee34015d6ddb26478422fd0c","count":25},{"descriptor":"Fornebu, Norway (ZNO11)","id":"ba927ad987ee01020389e6b494000000","count":1},{"descriptor":"Fort Collins, CO (CO29)","id":"4114a9c5ddc501787dea77fde7019936","count":2},{"descriptor":"Fort Worth, TX (TX135)","id":"731a6d25b4bc01260a2ef4efbe0b4e60","count":2},{"descriptor":"Framingham, MA","id":"442a24924422100157ed1e5a4c5c0000","count":2},{"descriptor":"Fresno, CA (CA180)","id":"4114a9c5ddc501232fd3ac42e7010636","count":2},{"descriptor":"Ft. Lauderdale, FL (FL87)","id":"da5e91a4328101abe15bda8ec823a9bc","count":3},{"descriptor":"Georgia, US Offsite","id":"f1180d181cc140dba59dd0e993a002f1","count":15},{"descriptor":"Georgia Remote Work","id":"a2aa2501ee3401b67a9904478422df0c","count":15},{"descriptor":"Germany Offsite (ZWG99)","id":"5c1aee55369b44a2a5136da8dec8e315","count":6},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Glostrup, Denmark (ZDK02)","id":"27a1c404f5744ae68442996960fe2804","count":3},{"descriptor":"Greater Chicago Area","id":"a2aa2501ee34015128ebf2468422d00c","count":15},{"descriptor":"Greater Dallas Area","id":"a2aa2501ee34013ba7b67b4584229a0b","count":1},{"descriptor":"Gurgaon, India","id":"d879770ce5801001ba2441f0f8260000","count":4},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1},{"descriptor":"Ho Chi Minh, Vietnam","id":"04fbb808deef1000aba4980e9ce60000","count":2},{"descriptor":"Ho Chi Minh City, Vietnam (ZVI16)","id":"da5e91a4328101b8bd368cee2324adf1","count":1},{"descriptor":"Idaho, US Offsite","id":"de8af0de8a4f43e49ea4d4dc5a432216","count":1},{"descriptor":"Idaho Remote Work","id":"a2aa2501ee3401e0c730f9468422d50c","count":2},{"descriptor":"Idstein, Germany (ZWG86)","id":"04a42199937044bbbf6010ed72d1d007","count":2},{"descriptor":"Illinois, US Offsite","id":"037ebcbfd6ee4ad8a96ca2f9ec955366","count":36},{"descriptor":"Illinois Remote Work","id":"a2aa2501ee3401b4149aec468422cb0c","count":29},{"descriptor":"Indiana, US Offsite","id":"86ac456645c1476581ccafcdabd07091","count":11},{"descriptor":"Indianapolis, IN","id":"7f977422e7ba456a98281fb6d502202e","count":1},{"descriptor":"Indiana Remote Work","id":"a2aa2501ee3401181c56e6468422c60c","count":18},{"descriptor":"India Offsite (ZIN99)","id":"801ee26ff10b4e2389d3a9d125e02ae3","count":2},{"descriptor":"Iowa, US Offsite","id":"1787eed6fea6446f9bc1036e9a5962d9","count":2},{"descriptor":"Iowa Remote Work","id":"a2aa2501ee34012b9d0fda468422bc0c","count":7},{"descriptor":"Italy Offsite (ZIT99)","id":"7de50b13083047dfb5400de1b3b32aba","count":1},{"descriptor":"Kansas, US Offsite","id":"061f9780eeaf4ab392eb38562e8635c0","count":4},{"descriptor":"Kansas Remote Work","id":"a2aa2501ee3401a115bcd4468422b70c","count":5},{"descriptor":"Kentucky, US Offsite","id":"5e9d2bcbc1df436db79c28a492f83838","count":2},{"descriptor":"Kentucky Remote Work","id":"a2aa2501ee340110c46bcf468422b20c","count":2},{"descriptor":"Krakow, Poland","id":"cdb6c301cead01c0fd6255fbbe0073b9","count":89},{"descriptor":"Krakow, Poland","id":"30c4e7f824bd4b1a892b4ee4a537c2f7","count":2},{"descriptor":"Krakow, Poland","id":"3cc51f087f9747d5b0b2af9d001b0281","count":1},{"descriptor":"Kuala Lumpur, Malaysia","id":"817fef2f26ad4eec85f3d1f59f67a08c","count":2},{"descriptor":"Lexington, SC (SC07)","id":"da5e91a43281017cec012a9ab8239ba2","count":1},{"descriptor":"Linthicum, MD","id":"c152d08a5f9c104eed32617c8087529c","count":3},{"descriptor":"Lisbon, Portugal","id":"d0be8406d7eb01df5699f9468d8cf97d","count":9},{"descriptor":"Lisbon, Portugal","id":"60d771b675b201dd1b8cf4a90e01c534","count":1},{"descriptor":"Little Rock, AR","id":"9294dc0527c54192b5c8338f762402d1","count":1},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":3},{"descriptor":"Los Angeles, CA","id":"75eeec0cd30c4823b7cdbc46c87436e3","count":1},{"descriptor":"Los Angeles, CA","id":"20b991fa96e9475db727dbe3c7df1156","count":1},{"descriptor":"Louisiana Remote Work","id":"a2aa2501ee340134851ac4468422a80c","count":1},{"descriptor":"Machias, NY","id":"0a19dc5a4f9f4112af112d95245b34fc","count":1},{"descriptor":"Madrid, Spain","id":"8cfc0951b3b94bd98139c963eb68ec99","count":2},{"descriptor":"Maine, US Offsite","id":"992c04fd1a9c41d3a6a904ffe0de680c","count":3},{"descriptor":"Maine Remote Work","id":"a2aa2501ee34019d8ee2b74684229e0c","count":5},{"descriptor":"Manitoba Remote Work","id":"a2aa2501ee3401b8f6e9f44484222b0b","count":3},{"descriptor":"Maryland, US Offsite","id":"b83767d4324c46c999f575fd542abd88","count":16},{"descriptor":"Maryland Remote Work","id":"a2aa2501ee3401dbf94bb2468422990c","count":18},{"descriptor":"Massachusetts, US Offsite","id":"ef9ff0866473431aa0807077edea046d","count":18},{"descriptor":"Massachusetts Remote Work","id":"a2aa2501ee340136dff99f4684228a0c","count":13},{"descriptor":"Melbourne, Australia","id":"d7e3ba3b107b442382576d564fcbadfd","count":2},{"descriptor":"Mexico City, Mexico","id":"2b254088ddb54694997bd94b011e140c","count":4},{"descriptor":"Mexico Offsite","id":"5ef0f2a16491016a2dbdefc5034f5d9c","count":1},{"descriptor":"Michigan, US Offsite","id":"4b3514833681469ba0b512c446b25b97","count":11},{"descriptor":"Michigan Remote Work","id":"a2aa2501ee3401621d8898468422830c","count":13},{"descriptor":"Minnesota, US Offsite","id":"efb7395e01e54bde949ac224af8f56a6","count":3},{"descriptor":"Minnesota Remote Work","id":"a2aa2501ee34018daff981468422740c","count":9},{"descriptor":"Mississippi Remote Work","id":"a2aa2501ee340143de0a7c4684226f0c","count":2},{"descriptor":"Missouri, US Offsite","id":"fb75ff372ac14e1b809a1dd53333021e","count":2},{"descriptor":"Missouri Remote Work","id":"a2aa2501ee340123e99d6f468422650c","count":5},{"descriptor":"Montana, US Offsite","id":"add06bd26cdc4dcca751f6506e808c6a","count":1},{"descriptor":"Montana Remote Work","id":"a2aa2501ee3401c92dfa69468422600c","count":1},{"descriptor":"Morocco Offsite (ZMO99)","id":"13183554e71d4ea3b51cc01fb4310a38","count":1},{"descriptor":"Muscat, Oman","id":"7af2294c87014d38b73cc1f8e8046db2","count":1},{"descriptor":"Nebraska Remote Work","id":"a2aa2501ee3401c3ed27644684225b0c","count":1},{"descriptor":"Nevada, US Offsite","id":"63ba34e24ce44a5d92912e0cadae491c","count":1},{"descriptor":"Nevada Remote Work","id":"a2aa2501ee34015e595a5e468422560c","count":2},{"descriptor":"New Hampshire, US Offsite","id":"0727cec59d1544888ff072b50e96a1c3","count":5},{"descriptor":"New Hampshire Remote Work","id":"a2aa2501ee3401e10a2558468422510c","count":3},{"descriptor":"Newington, VA","id":"a2d68824ae0f4fdfa99ac487376a60c0","count":1},{"descriptor":"New Jersey, US Offsite","id":"dd456a04291641a5b02b5731f3e70d4a","count":10},{"descriptor":"New Jersey Remote Work","id":"a2aa2501ee340154abd2524684224c0c","count":14},{"descriptor":"New Mexico, US Offsite","id":"0bf30a8368014b0e90cd36a3c4d20e1a","count":2},{"descriptor":"New Mexico Remote Work","id":"a2aa2501ee3401cff79a46468422420c","count":4},{"descriptor":"New York, US Offsite","id":"3f76dd361d8b410784ca4fc8dc2421f7","count":8},{"descriptor":"New York Remote Work","id":"a2aa2501ee34015fb0b438468422380c","count":11},{"descriptor":"North Carolina, US Offsite","id":"2080bb98030b4515ba37427d91ff32cc","count":13},{"descriptor":"North Carolina Remote Work","id":"a2aa2501ee34015223b220468422210c","count":17},{"descriptor":"North Dakota, US Offsite","id":"a9996a2fd97f4d3e95a330c9526ec0b3","count":1},{"descriptor":"North Dakota Remote Work","id":"a2aa2501ee3401842df90e468422120c","count":3},{"descriptor":"NY52","id":"20a50c646bd31001a94e433910780000","count":1},{"descriptor":"Offsite France (ZFR99)","id":"71f31ba331b642f3a3ae05b211a469d1","count":1},{"descriptor":"Ohio, US Offsite","id":"c9f53b4342e94035b77570cfe5599af6","count":15},{"descriptor":"Ohio Remote Work","id":"a2aa2501ee34011ff5ccfc458422030c","count":14},{"descriptor":"Oklahoma, US Offsite","id":"7ceb761aa15d46d7b6c9a6bb4d05c509","count":4},{"descriptor":"Oklahoma Remote Work","id":"a2aa2501ee3401d33bbaf6458422fe0b","count":4},{"descriptor":"ONT39","id":"5c4e189f92a610016f2ffc6e5c630000","count":1},{"descriptor":"Ontario Remote Work","id":"a2aa2501ee340179e5f7e8448422210b","count":10},{"descriptor":"Oregon, US Offsite","id":"746c5cc1f07d48d7837f3db4895a18e7","count":10},{"descriptor":"Oregon Remote Work","id":"a2aa2501ee3401d4d45ff0458422f90b","count":6},{"descriptor":"Orlando, FL","id":"b7c95ddf5a041015a61c88e160676351","count":2},{"descriptor":"Oslo, Norway (ZNO07)","id":"8ef71253a56d4aaf92ff5a5364ccc8ac","count":1},{"descriptor":"Ottawa, Canada","id":"77e555f21e5501db407373e92a70fa79","count":1},{"descriptor":"Parma, OH","id":"9efafca5ae9041f7980582836384f807","count":1},{"descriptor":"Penang, Malaysia","id":"c6d7e2b64f8b107f215186f1d658a224","count":56},{"descriptor":"Penang, Malaysia","id":"8dfc527f8ed44cee87fe36c1afbaf264","count":1},{"descriptor":"Penang, Malaysia","id":"168b0d8a3214463583f95156388faf2d","count":1},{"descriptor":"Pennsylvania, US Offsite","id":"89941ac3741f436ab4e333e49a8fba84","count":16},{"descriptor":"Pennsylvania Remote Work","id":"a2aa2501ee3401fe0c4ed8458422e50b","count":12},{"descriptor":"Phoenix, AZ","id":"d0be8406d7eb01fa50265759958cbf87","count":1},{"descriptor":"Plantation, FL","id":"17ba885223814f9ab57dedd1e725b00a","count":7},{"descriptor":"Plantation, FL","id":"d879770ce5801001b9b947c3860f0000","count":1},{"descriptor":"Poland Offsite (ZPL99)","id":"9587715495c14b2b946ee753f5adba22","count":8},{"descriptor":"Portugal Offsite (ZPT99)","id":"22e48e01af704af5acf68a768e1184ed","count":1},{"descriptor":"Puerto Rico Offsite","id":"c35e2c7bf9b1444bb4c00699df114d76","count":1},{"descriptor":"Quebec Remote Work","id":"a2aa2501ee34017ab529dc448422170b","count":6},{"descriptor":"Reynosa, Mexico","id":"2cc4589d2ab01001021366bdbd430000","count":2},{"descriptor":"Rhode Island, US Offsite","id":"75ccaab07ff843b4bb5433ed70cbaff7","count":4},{"descriptor":"Rhode Island Remote Work","id":"a2aa2501ee34018f99a6c6458422d60b","count":1},{"descriptor":"Richardson, TX (TX141)","id":"a1b4b9c5b61b016ad44e1b6108028e25","count":1},{"descriptor":"Richmond, VA","id":"9ea53914b84d01586593035807010e1b","count":1},{"descriptor":"Riyadh, Saudi Arabia","id":"dfff2595c3404fe89fcea0c4a139065c","count":2},{"descriptor":"Romania Offsite (ZRO99)","id":"88268c4ae43b48c1bd5baa7007a31a71","count":1},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Sacramento, CA","id":"c4ee93d3538249b29c9fb0bfde3295be","count":1},{"descriptor":"San Mateo, CA","id":"3955e91ab9be1000d6a5f34dfd560000","count":1},{"descriptor":"Santiago, Chile","id":"ff21797042291056c1ed919d43474a6f","count":2},{"descriptor":"Santiago, Chile","id":"ff21797042291056c2a0d44e6f564d8b","count":1},{"descriptor":"Sao Paulo, Brazil","id":"d234454abe5110015dd3a0c5bb570000","count":5},{"descriptor":"Sarasota, FL","id":"279a8a3ddd4d018ef74c6ecba500157e","count":1},{"descriptor":"Saskatchewan Remote Work","id":"a2aa2501ee34019300f5d5448422120b","count":3},{"descriptor":"Schaumburg, IL","id":"5983637b827e4ed097966aa984c7cf6c","count":9},{"descriptor":"Schaumburg, IL","id":"f90bd5bcf3df4205a301db42c4557bdd","count":1},{"descriptor":"Schio, Italy","id":"a66ea95a586801014b0a39c8aa730000","count":1},{"descriptor":"Seoul, Korea","id":"8c4c7f5076070100bf635b3ff800ed4e","count":1},{"descriptor":"Singapore, Singapore","id":"914a4f61913c10357f56e7fd0de4f904","count":1},{"descriptor":"Singapore, Singapore (ZSG38)","id":"c6d7e2b64f8b107f233884cad328a5a5","count":1},{"descriptor":"Somerville, MA","id":"d0be8406d7eb01197d6786d18c8c617d","count":2},{"descriptor":"South Carolina, US Offsite","id":"4548f2167eca45daaa61d7c4aa7d08da","count":2},{"descriptor":"South Carolina Remote Work","id":"a2aa2501ee3401ac594eb9458422cc0b","count":10},{"descriptor":"South Dakota, US Offsite","id":"520ca850ee1443438ff88ea729c5dc1f","count":1},{"descriptor":"South Dakota Remote Work","id":"a2aa2501ee3401e9b731b3458422c70b","count":2},{"descriptor":"Spain Offsite (ZES99)","id":"301a357729b94516a34e3a61a35c1bb5","count":1},{"descriptor":"St. Petersburg, FL (FL92)","id":"4114a9c5ddc501b041023c10a301a7b6","count":1},{"descriptor":"Sterling, VA","id":"ca833823055501ee67c0d0e6ff01d6ee","count":1},{"descriptor":"St Petersburg, FL","id":"b9d0a434256f01442efa8db524cf8e23","count":1},{"descriptor":"Switzerland Offsite (ZSW99)","id":"bc6c8eecc49e4078ac65cd83165d02c5","count":1},{"descriptor":"Sydney, Australia (ZAS102)","id":"a161ce532f951001110b54a8d1f80000","count":1},{"descriptor":"Taguig, Philippines","id":"c6c7d41a752501ed42def116f4000e0e","count":1},{"descriptor":"Tennessee, US Offsite","id":"aa9f12002a984c16858ff0b2be54fce4","count":14},{"descriptor":"Tennessee Remote Work","id":"a2aa2501ee3401a15dcfac458422c20b","count":15},{"descriptor":"Texas, US Offsite","id":"7951f208c4a44af291de95d7063ca8ea","count":34},{"descriptor":"Texas Remote Work","id":"a2aa2501ee3401bb3ac08d458422a90b","count":26},{"descriptor":"Tokyo, Japan","id":"8c4c7f50760701262d4b1accf800fb4f","count":1},{"descriptor":"Toronto, Canada (ONT40)","id":"442a249244221001582c47e270eb0000","count":6},{"descriptor":"United Arab Emirates Offsite (ZUA99)","id":"dcc3bd6cdddc4454ad3336c2520953a5","count":1},{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":20},{"descriptor":"Utah, US Offsite","id":"f61b91f41da34642ae840d013eb6ec7d","count":19},{"descriptor":"Utah Remote Work","id":"a2aa2501ee3401463afc6e458422900b","count":11},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Vancouver, Canada","id":"d0be8406d7eb01e1ef6d1c418c8cf679","count":8},{"descriptor":"Vermont Remote Work","id":"a2aa2501ee3401d6729461458422840b","count":3},{"descriptor":"Versailles, France","id":"7dda71e222860100ab254c24897f0000","count":1},{"descriptor":"Vienna, Austria","id":"46a2113a7c421062bd06fb72dee26f45","count":1},{"descriptor":"Virginia, US Offsite","id":"c6987245ed6b4552b729aa8ca40c084f","count":16},{"descriptor":"Virginia Remote Work","id":"a2aa2501ee3401aefdf55a4584227f0b","count":11},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Warsaw, Poland","id":"d4e8b75046371067ca56ac231068e8e9","count":2},{"descriptor":"Warsaw, Poland","id":"c3422e7a11fd466e8a10d70edc3171ce","count":2},{"descriptor":"Washington, US Offsite","id":"0270f0ddaa9c4df780efe79b9477a4dc","count":5},{"descriptor":"Washington DC, US Offsite","id":"6703b0349e294f7982d1105b4180e6bf","count":4},{"descriptor":"Washington DC Remote Work","id":"a2aa2501ee34012ca4a4274484228b0a","count":6},{"descriptor":"Washington Remote Work","id":"a2aa2501ee3401c3bf02344584225d0b","count":10},{"descriptor":"Westminster, CO","id":"435c641825b8436a950f0c3c604cc62e","count":1},{"descriptor":"West Valley City, UT","id":"dc4b44bb9c9210367f2102c8f37b8c34","count":2},{"descriptor":"West Virginia, US Offsite","id":"41c94f5726b54db19a40ed8ab4c7016f","count":1},{"descriptor":"West Virginia Remote Work","id":"a2aa2501ee3401a5c1d62d458422580b","count":3},{"descriptor":"Wisconsin, US Offsite","id":"e350deb449e548d7be5c7185f399be05","count":3},{"descriptor":"Wisconsin Remote Work","id":"a2aa2501ee340159152027458422530b","count":14},{"descriptor":"Woodcliff Lake, NJ","id":"56b899ac82d3102ebddb9e5d99cf2205","count":2},{"descriptor":"Wyoming, US Offsite","id":"857b68215cb8413f8fc0085cc2df67b3","count":1},{"descriptor":"Wyoming Remote Work","id":"a2aa2501ee3401412f02214584224e0b","count":4},{"descriptor":"ZAS100","id":"20a50c646bd31001a8ec21fd6d5f0000","count":2}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:40 GMT
 - request:
     method: post
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/jobs
@@ -385,7 +91,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:39 GMT
+      - Tue, 30 Jul 2024 16:26:41 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -399,41 +105,41 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=dea9e87e0c2ace8c16ec9f257289248cc61355ba-instance=vps-prod-1vd0ucv5.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=f2e980771c24088c4052fa1aa3c5d3a4d6c92205-instance=vps-prod-vwebqnqw.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=g9RrIAkfv0zTKw1rt9WTrIt8B.oqKI51KnqDJjewY98-1722244479-1.0.1.1-z4AVqQ1e7qIp_yN0gGEQhrwHwFsi_PSuwYr4AmBDYWV7idfuwmBG65lqWU3n0ri2Ncc9V87qLYsXUszeGDTZ9w;
-        path=/; expires=Mon, 29-Jul-24 09:44:39 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=yeB.ci9BekkzBA23zoLgmzP5hWjzCU9heEM2SZIwcHE-1722356801-1.0.1.1-Jb17g1WRmJUF0oHioTCmMVY4Bvxu8ObXMFAIb.Z4jwXEfk_rjiSEv6UQX1GnpwszfcDkvv9FWWaIJu9U8zLrfg;
+        path=/; expires=Tue, 30-Jul-24 16:56:41 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKNFTtNTjdFAZDpBKYwYghVGoCHX2; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:39 GMT; HttpOnly
-      - _cfuvid=.dK6r0dwXvVq45s_MWUxmEG2BY_5oJ.CcxOAstRIoRg-1722244479570-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxexxBahhrUX1mE; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:41 GMT; HttpOnly
+      - _cfuvid=QoTjpTPu879_S7m9ozOK7ZQgMp6aFXsRBVbA_mlAHgA-1722356801186-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=c591272e-252e-4669-8513-cfd627485271; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=1122671626.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=a9f04c20-9e09-4185-9361-e9c2b40bec1f; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=3018628106.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|24cec6e5-d81a-431b-9870-5565bae73fea
+      - VPS|53a4cb52-89db-4253-96a7-0f0ceac51fa2
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - DYNAMIC
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=jXP10goWWbyKMQLUSF0ANBZwbqtioat8jsITq9wVAq%2F9PoO04b3S0E%2FFzx3duhGBxMpCZr8cZyN7wehofNuaIV9Hxj%2F1yv8GothPg41S7GnzpvcIkdMzgQxj4KQBr3a5ZgHYWKcbw5oHDdWfBJgnU02QxiSOvx04MA%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=l5W%2Fn67yQVi%2Fju3VazLVB8In3DfMnnLZoVwNmS72ZO96UnpIHddRvtYIoXMe2j9dPzDOusQA6bYuMA1j4LPalVmDA3lEKgbfAaQGfAGLrDZJIdzHkor3YqIVrDh9bsn3aGScJAt1Rmwp84H8MXerpjsh8MjieXYbZQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aabfffa1b9b7cf4-EWR
+      - 8ab6b6353f5b43be-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"total":35,"jobPostings":[{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48791","Rugby, UK (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48793","Rugby, UK (ZUK107)"]},{"title":"Senior Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Software-Engineer_R48898-1","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 3 Days Ago","bulletFields":["R48898","Edinburgh, UK (ZUK129)"]},{"title":"Digital Campaigns Manager - EMEA","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Digital-Campaigns-Manager---EMEA_R45720","locationsText":"United Kingdom Offsite (ZUK99), More...","postedOn":"Posted 4 Days Ago","bulletFields":["R45720","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - North England & Midlands","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---Midlands_R48681","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 4 Days Ago","bulletFields":["R48681","United Kingdom Offsite (ZUK99)"]},{"title":"Technical Project Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Technical-Project-Manager_R47762","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 4 Days Ago","bulletFields":["R47762","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---South_R48682","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 5 Days Ago","bulletFields":["R48682","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Transmission Design Engineer / Authority","externalPath":"/job/Rugby-UK-ZUK107/Senior-Transmission-Design-Engineer---Authority_R48609","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 5 Days Ago","bulletFields":["R48609","Rugby, UK (ZUK107)"]},{"title":"Senior FP&A Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Senior-FP-A-Manager_R48163","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 6 Days Ago","bulletFields":["R48163","United Kingdom Offsite (ZUK99)"]},{"title":"Account Director – South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Account-Director---South_R48669","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 11 Days Ago","bulletFields":["R48669","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Frontend Developer","externalPath":"/job/Uxbridge-UK-ZUK131/Senior-Frontend-Developer_R48511","locationsText":"Uxbridge, UK (ZUK131), More...","postedOn":"Posted 13 Days Ago","bulletFields":["R48511","Uxbridge, UK (ZUK131)"]},{"title":"Regional Sales Director, CAM UK & Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Regional-Sales-Director--CAM-UK---Ireland_R48590","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 13 Days Ago","bulletFields":["R48590","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Sales Executive - South East","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---South-East_R48471","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 13 Days Ago","bulletFields":["R48471","United Kingdom Offsite (ZUK99)"]},{"title":"Senior System Engineer","externalPath":"/job/Rugby-UK-ZUK107/Senior-System-Engineer_R48513","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 14 Days Ago","bulletFields":["R48513","Rugby, UK (ZUK107)"]},{"title":"Channel Marketing Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Marketing-Manager_R47820-1","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 18 Days Ago","bulletFields":["R47820","United Kingdom Offsite (ZUK99)"]},{"title":"Software Configuration and Integrations Engineer","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Software-Configuration-and-Integrations-Engineer_R48514","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 18 Days Ago","bulletFields":["R48514","United Kingdom Offsite (ZUK99)"]},{"title":"Sr. Manager U.K. and Ireland Communications","externalPath":"/job/London-UK/Sr-Manager-UK-and-Ireland-Communications_R48263-1","locationsText":"London, UK","postedOn":"Posted 27 Days Ago","bulletFields":["R48263","London, UK (ZUK120)"]},{"title":"Junior Software Engineer","externalPath":"/job/Glasgow-UK-ZUK118/Junior-Software-Engineer_R47941","locationsText":"Glasgow, UK (ZUK118)","postedOn":"Posted 27 Days Ago","bulletFields":["R47941","Glasgow, UK (ZUK118)"]},{"title":"Senior Embedded Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Embedded-Software-Engineer_R47952","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 30+ Days Ago","bulletFields":["R47952","Edinburgh, UK (ZUK129)"]},{"title":"Channel Sales Executive - Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---Ireland_R48205","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48205","United Kingdom Offsite (ZUK99)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":16},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":6},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":4},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":3},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":3},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":2},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":1}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":35}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":35}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":227},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":96},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":64},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":60},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":35},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":24},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":19},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":9},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":8},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":5},{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":2},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":2},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"Taiwan","id":"a4e08b475d6a4176853c9d1cb9854e02","count":1},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":21},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":4},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
-  recorded_at: Mon, 29 Jul 2024 09:14:39 GMT
+        {"total":34,"jobPostings":[{"title":"Technical Support Specialist","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted Yesterday","bulletFields":["R48704","United Kingdom Offsite (ZUK99)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Yesterday","bulletFields":["R48791","Rugby, UK (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Yesterday","bulletFields":["R48793","Rugby, UK (ZUK107)"]},{"title":"Senior Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Software-Engineer_R48898-1","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 4 Days Ago","bulletFields":["R48898","Edinburgh, UK (ZUK129)"]},{"title":"Channel Account Manager - North England & Midlands","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---Midlands_R48681","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 5 Days Ago","bulletFields":["R48681","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---South_R48682","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 6 Days Ago","bulletFields":["R48682","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Transmission Design Engineer / Authority","externalPath":"/job/Rugby-UK-ZUK107/Senior-Transmission-Design-Engineer---Authority_R48609","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 6 Days Ago","bulletFields":["R48609","Rugby, UK (ZUK107)"]},{"title":"Senior FP&A Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Senior-FP-A-Manager_R48163","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 7 Days Ago","bulletFields":["R48163","United Kingdom Offsite (ZUK99)"]},{"title":"Account Director – South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Account-Director---South_R48669","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 12 Days Ago","bulletFields":["R48669","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Frontend Developer","externalPath":"/job/Uxbridge-UK-ZUK131/Senior-Frontend-Developer_R48511","locationsText":"Uxbridge, UK (ZUK131), More...","postedOn":"Posted 14 Days Ago","bulletFields":["R48511","Uxbridge, UK (ZUK131)"]},{"title":"Regional Sales Director, CAM UK & Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Regional-Sales-Director--CAM-UK---Ireland_R48590","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 14 Days Ago","bulletFields":["R48590","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Sales Executive - South East","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---South-East_R48471","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 14 Days Ago","bulletFields":["R48471","United Kingdom Offsite (ZUK99)"]},{"title":"Senior System Engineer","externalPath":"/job/Rugby-UK-ZUK107/Senior-System-Engineer_R48513","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 15 Days Ago","bulletFields":["R48513","Rugby, UK (ZUK107)"]},{"title":"Channel Marketing Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Marketing-Manager_R47820-1","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 19 Days Ago","bulletFields":["R47820","United Kingdom Offsite (ZUK99)"]},{"title":"Software Configuration and Integrations Engineer","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Software-Configuration-and-Integrations-Engineer_R48514","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 19 Days Ago","bulletFields":["R48514","United Kingdom Offsite (ZUK99)"]},{"title":"Sr. Manager U.K. and Ireland Communications","externalPath":"/job/London-UK/Sr-Manager-UK-and-Ireland-Communications_R48263-1","locationsText":"London, UK","postedOn":"Posted 28 Days Ago","bulletFields":["R48263","London, UK (ZUK120)"]},{"title":"Junior Software Engineer","externalPath":"/job/Glasgow-UK-ZUK118/Junior-Software-Engineer_R47941","locationsText":"Glasgow, UK (ZUK118)","postedOn":"Posted 28 Days Ago","bulletFields":["R47941","Glasgow, UK (ZUK118)"]},{"title":"Senior Embedded Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Embedded-Software-Engineer_R47952","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 30+ Days Ago","bulletFields":["R47952","Edinburgh, UK (ZUK129)"]},{"title":"Channel Sales Executive - Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---Ireland_R48205","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48205","United Kingdom Offsite (ZUK99)"]},{"title":"Finance Business Partner","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Finance-Business-Partner_R48124","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48124","United Kingdom Offsite (ZUK99)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":15},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":6},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":5},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":3},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":2},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":2},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":1}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":34}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":34}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":236},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":94},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":61},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":58},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":34},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":23},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":21},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":10},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":6},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":5},{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":1},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Korea, Republic of","id":"7a5a2aadf9d34086a2bfbfd408bc28da","count":1},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":20},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":3},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:41 GMT
 - request:
     method: get
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/sidebar
@@ -453,7 +159,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:40 GMT
+      - Tue, 30 Jul 2024 16:26:41 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -463,41 +169,41 @@ http_interactions:
       Vary:
       - accept-language,accept-encoding
       Set-Cookie:
-      - PLAY_SESSION=b776308a7f4c9e69053a4f2d2073ff3adfeaafb5-instance=vps-prod-pie37xp2.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=b1400e38ee54fff08723d08e9187c1635fd495fd-instance=vps-prod-ka2d8tvk.prod-vps.pr501.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=RG8yyXccdFvRzr5aS78y82kjpC2byQKZjTmI1kJfHGM-1722244480-1.0.1.1-q69N0LVpyKvaxSTafNM0a.lujHumwcXwGL9yfVmAgRGwg4NoPLwORyL8a8uMpcGS8YJhGdJRk07mZY6W.1w3LQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:40 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=_lsJuHHMJnZzqutDHggHreDPN8wjijnnxoNYFDneXk4-1722356801-1.0.1.1-yo.bou47NdPdfrUOEYLeCB3qxxQwIxYksM30laej4xZ2LYbD.Gc3T7eFMes22ZNZyF.fJLk5lvK_Wsjj_VESYg;
+        path=/; expires=Tue, 30-Jul-24 16:56:41 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKNFTtNTjdFAZDpBKZgNCu3vRTx1S; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:40 GMT; HttpOnly
-      - _cfuvid=GP5YgagqCRq5BC3a7vwbRmi9yNVllJVmM333AZ3JOXI-1722244480408-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKNFTtNTjdFAZDpBJm7k3chceMcQL; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:41 GMT; HttpOnly
+      - _cfuvid=uDadoisUYYKpb5LyJBkODGUWcuKn.1J38L2bFiGICPQ-1722356801724-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=cf7fdc40-d504-4615-a764-68b1bd877392; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=401251338.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=366a6b2b-60e1-4d88-a311-951ec77e5a12; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=1877646346.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - max-age=259200, public,
       X-Wd-Request-Id:
-      - VPS|3dcc4e97-d0fa-451f-93ee-42700e6160f5
+      - VPS|ee8d375a-b4bf-4236-892f-122300c44023
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - BYPASS
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=YhlgcNm%2F1YnzktzlSujdQTtuC8DxlNCdcTce46PVgnLyktBR%2FGfG1YQr6%2FX6euZ7VW3trygQclQoH4lrqE%2FunDku1T1OjObKYKT8ZR9FylYHOSWQJjftxgtBPR8EANJKLtf%2BKTx3XU2S%2BX6ZEA710zTPNSmG%2FXBtyw%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=oucQoIJDyKt9cWY36QyCRRvNhmFepnAKFNioF7uIki5eKoKgeXuE%2B8bT29fEB7bK960ZKQNJcRHys4EuLcR0%2BGIFMzrHITNsFS9RFsuwsGujlVEDqGqLG9DKC6CtBClupFl%2BA08WIKH0WmhJY0cuYEhzk%2Ba6K4yxEg%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac000198b87d06-EWR
+      - 8ab6b639d84141cd-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
         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
-  recorded_at: Mon, 29 Jul 2024 09:14:40 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:41 GMT
 - request:
     method: get
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/approot
@@ -517,7 +223,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:41 GMT
+      - Tue, 30 Jul 2024 16:26:42 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -527,42 +233,42 @@ http_interactions:
       Vary:
       - accept-language,accept-encoding
       Set-Cookie:
-      - PLAY_SESSION=877bacfe87adda199b2a2be6bbe8f288521f7524-instance=vps-prod-h731w70j.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=32d42d769dfa70422b157c55289ad7badf2bd196-instance=vps-prod-2fjn89f6.prod-vps.pr501.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=.QH0A1Ou4cy.Z7z_J4kPL5Vjcg5VPcK7mFbZ1Ku1a2M-1722244481-1.0.1.1-WQPNgWTGTLe9k4b67dO5_En4upFyAIzv1txSn.s3GI1V1gGzo4CQVcRg5FivkNCa1ujTBXLkzlgsnbadkjPtqQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:41 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=WGTyJ1CAEvkH2lZPB5a824bCkSwvK76bo_qYnV5nBmo-1722356802-1.0.1.1-18molzW.F6oEL.nhaNPyejqRRVdkdqZ9_jSgdsagHfQVMcOrsGAUKXl_S4YBVh9ahDSqvDqB8qA_80YqfiuUaQ;
+        path=/; expires=Tue, 30-Jul-24 16:56:42 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxfnFdGBcosu1rk; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:41 GMT; HttpOnly
-      - _cfuvid=MbMfdV0hSvqqqiApZGj8iqHd.jBidBJUZ57oWD1DjeY-1722244481349-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLeTYyWYf7NxYcM1ZG6tfvpan7sa; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:42 GMT; HttpOnly
+      - _cfuvid=rl6jD5JxMmvNUENyhioAt37Lv6t.JxdaDwqAUEshLSQ-1722356802320-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=a66dcd97-00e6-4528-bc49-ce0d42bd3fe5; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=350919690.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=eec4591f-895e-435d-bcda-a6b57ff31282; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=1995086858.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - max-age=1800, public,
       X-Wd-Request-Id:
-      - VPS|ccb53b53-d3ae-400d-93d8-7a9f84dce7ff
+      - VPS|59ee939a-272a-4324-aa08-1a705f39b1e9
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - BYPASS
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=uisvnaZaGQWSALRYVG1hFBfdCvC8enmrpNpK2BYc%2F%2BPZpQTQuqUDkjzc8V2BRlj4dATvBETM7Q%2BocVhmdpGDKY98c92RLPHeWPjvmaccPeab2lu%2Fv2%2FeTqG8gvghf%2FYg8kimrK6P4XWpgCcMS4UAIX0KFRvWmxWtCw%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=J7dX0xzKorPfHul%2FFziEFxnsdnMABhuCGfWAJNGS0IBB%2FgnfrhzKFaxz8AF5ZR2DQ0GzJSaOlleb9mhrbSTlMwH3499moaMXmaLW2O1AjIhwwWvF%2BzMIfyle3o9Iq5JN46ZlEQqqqYl1klPJ%2FEFkkrokyq03ypV%2F1Q%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac00055ac6c334-EWR
+      - 8ab6b63d08c432e2-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
-      string: '{"applyWithProfile":{"linkedIn":{"serviceAPIKey":"86eto2o4dqjyip","gadgetServerBaseURL":"https://applywithlinkedin.myworkdaygadgets.com","integrationContextId":"urn:li:organization:1771432","requireCookieAcceptance":false},"seek":{"advertiserId":"36467863"}},"analytics":{"googleUniversalAnalyticsID":"G-F1YSDPN56M"},"brandingData":{"progressBar":{"color":"#0066FF"},"button":{"primary":{"color":"#FF9933","borderColor":"#FF9933","textColor":"#FFFFFF","hover":{"color":"#E67300","borderColor":"#E67300","textColor":"#FFFFFF"}},"secondary":{"color":"#CCCCCC","borderColor":"#CCCCCC","textColor":"#000000","hover":{"color":"#999999","borderColor":"#999999","textColor":"#000000"}},"shape":"PILL"},"header":{"imageBanner":{"maintainAspectRatio":true},"banner":{"color":"#FFFFFF","borderColor":"#999999","textColor":"#000000","image":{"id":"8975f0c92a7d10015b8e9bf8009f0000"}}},"embedded":false},"chatbotConfiguration":{"paradoxWidgetToken":null},"configuredText":{"applyConfirmationMessage":"<p>Your
-        application has been submitted, thank you for your interest in Motorola Solutions!</p>","introduceYourself":"Tell
-        us About You","countryCustomLabel":"Country","countryPhoneCodeCustomLabel":"Country
-        Phone Code"},"consentConfiguration":{"consentConfigurationVendor":{"id":"9de36ec94084100013e8560e84170000","descriptor":"Workday"},"oneTrustUrl":null},"facets":["jobFamilyGroup","locationCountry","distance","locations","timeType","timeType123"],"featureFlags":{"skillsCloud":true,"candidateAccounts":true,"requireCandidateAccounts":true,"introduceYourself":true,"preferredName":true,"embedMode":false,"hideSearchForJobs":false,"jobAlerts":true,"useAlternateCountryLabel":false,"excludeSiteIndexing":false,"specialties":false,"accountVerification":false},"footer":{"socialLinksList":[{"label":"Twitter","uri":"https://twitter.com/MotoSolutions"},{"label":"Facebook","uri":"https://www.facebook.com/MotorolaSolutions/"},{"label":"LinkedIn","uri":"https://www.linkedin.com/company/motorolasolutions/"}],"privacyPolicy":{"label":null,"uri":null}},"header":{"homePageURL":"https://www.motorolasolutions.com/en_us/about/careers.html","homeLinkText":"Careers","imageBannerUri":"/Careers/assets/banner","logoUri":"/Careers/assets/logo","cookieBanner":{"message":"<p><b><span>Motorola
+      string: '{"applyWithProfile":{"linkedIn":{"serviceAPIKey":"86eto2o4dqjyip","gadgetServerBaseURL":"https://applywithlinkedin.myworkdaygadgets.com","integrationContextId":"urn:li:organization:1771432","requireCookieAcceptance":false},"seek":{"advertiserId":"36467863"}},"analytics":{"googleUniversalAnalyticsID":"G-F1YSDPN56M"},"brandingData":{"progressBar":{"color":"#0066FF"},"button":{"primary":{"color":"#FF9933","borderColor":"#FF9933","textColor":"#FFFFFF","hover":{"color":"#E67300","borderColor":"#E67300","textColor":"#FFFFFF"}},"secondary":{"color":"#CCCCCC","borderColor":"#CCCCCC","textColor":"#000000","hover":{"color":"#999999","borderColor":"#999999","textColor":"#000000"}},"shape":"PILL"},"header":{"imageBanner":{"maintainAspectRatio":true},"banner":{"color":"#FFFFFF","borderColor":"#999999","textColor":"#000000","image":{"id":"8975f0c92a7d10015b8e9bf8009f0000"}}},"embedded":false},"chatbotConfiguration":{"paradoxWidgetToken":null},"configuredText":{"introduceYourself":"Tell
+        us About You","applyConfirmationMessage":"<p>Your application has been submitted,
+        thank you for your interest in Motorola Solutions!</p>","countryPhoneCodeCustomLabel":"Country
+        Phone Code","countryCustomLabel":"Country"},"consentConfiguration":{"consentConfigurationVendor":{"id":"9de36ec94084100013e8560e84170000","descriptor":"Workday"},"oneTrustUrl":null},"facets":["jobFamilyGroup","locationCountry","distance","locations","timeType","timeType123"],"featureFlags":{"excludeSiteIndexing":false,"embedMode":false,"requireCandidateAccounts":true,"skillsCloud":true,"hideSearchForJobs":false,"jobAlerts":true,"specialties":false,"accountVerification":false,"introduceYourself":true,"useAlternateCountryLabel":false,"candidateAccounts":true,"preferredName":true},"footer":{"socialLinksList":[{"label":"Twitter","uri":"https://twitter.com/MotoSolutions"},{"label":"Facebook","uri":"https://www.facebook.com/MotorolaSolutions/"},{"label":"LinkedIn","uri":"https://www.linkedin.com/company/motorolasolutions/"}],"privacyPolicy":{"label":null,"uri":null}},"header":{"homePageURL":"https://www.motorolasolutions.com/en_us/about/careers.html","homeLinkText":"Careers","imageBannerUri":"/Careers/assets/banner","logoUri":"/Careers/assets/logo","cookieBanner":{"message":"<p><b><span>Motorola
         Solutions values your privacy</span></b><br /><br /><span>Our website is set
         to allow cookies. We use cookies to improve your website experience, the products
         and services we offer and to make your digital experience personalized to
@@ -571,7 +277,7 @@ http_interactions:
         our </span><a href=\"https://motorolasolutions.com/en_xu/about/privacy-policy.html#cookies\"
         target=\"_blank\">Cookie Policy</a><span>.</span></p>","policy":"EVERYWHERE"}},"languages":[{"descriptor":"English","languageCode":"en_US"}],"mlEnabled":true,"recommendedJobsEnabled":true,"tenantDefaultCountry":{"id":"bc33aa3152ec42d4995f4791a106ed09","descriptor":"United
         States of America"},"toggles":["466d58ad03691000185ddce1282a0000","bc814e895c1d10000d1fd3354f4b0000","20ccbc6c60701000fafdc3dce74a0000","10f7a56eb11c100024a6d65b625a0000","547aef155f9510000b557900e89a0000","548d61215c4810001cce239053870000"]}'
-  recorded_at: Mon, 29 Jul 2024 09:14:41 GMT
+  recorded_at: Tue, 30 Jul 2024 16:26:42 GMT
 - request:
     method: post
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/jobs
@@ -593,7 +299,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:42 GMT
+      - Tue, 30 Jul 2024 16:26:43 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -607,335 +313,41 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=9690f10776985a1d62f604602bdac2033b10cb48-instance=vps-prod-j66ym6rm.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=db41414e9dc7556e5e69ce769c1d05ef687842a9-instance=vps-prod-dc90h1lm.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=8JKAtg9BJ225p1SfNgwdDKN0Bsz2mxebC.CNSFQM478-1722244482-1.0.1.1-vpGYpaAEEeAIb5ZB8qKrWrEvktLw2NvntR8SoXMQ4K._OK2FLia01H4kHzlaoSt_k1M31.X8RYvTKmihlZLTaQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:42 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=06bx8zMzj.s94gYZZ0o._ULp9iGf2XBCFifvjzWe3Wg-1722356803-1.0.1.1-YsVX.RYGav1M2kdoOabUz7z.nzFqBw8IDgu1FcESCUurKpKWVvFMyzS7dgdAfJCtnL4K9lFcqZUZ1JKumo1koA;
+        path=/; expires=Tue, 30-Jul-24 16:56:43 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKNFTtNTjdFAZDpBKaRBj6ca3jcVr; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:42 GMT; HttpOnly
-      - _cfuvid=ZXVsSFH5nH0jf7znMe2cWjTBJX_UvdlQHzRQpKETf8E-1722244482609-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxezRpd6q9j4Lk4; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:43 GMT; HttpOnly
+      - _cfuvid=H0X32iJP.uZyELOYMUblfQqXAhBHYcTHsfM12XaNZbU-1722356803265-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=d5abd0bb-e0f0-4fdb-abf0-6f4e2c6feaf1; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=1760205834.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=7c8af488-72b0-468a-ac5a-d0790351885e; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=3186400266.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|e53f5726-a8c8-4ce4-8d07-137fe8d1cbb5
+      - VPS|46f530ce-81b2-41ff-96c0-b1961c28d035
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - DYNAMIC
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=5HLrSwugz1ATo%2FHqgymzclpo6bKTM2mWxHi11XiD3uAUWkYZncfv44gIXZor2sD%2Bl2haUq8j%2F97RsFjPIylAjnh%2B0ZEYRh81DJet55alkcjLVxunEjG161mOkpwP4A%2FftKV%2Fu7JbTP366YHU2gAOLyQ2crIs4uHQ%2Fw%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=P0ojWWTFqbs6iJNyI%2B0PIh83Lu0bVyI4QpDytg4Y2%2FCMC6186Daw4G8uyFshqKbP%2B7XKrZhHZmbHSN%2FrQ%2BZKOu6yK1eTK1473lf9wY7f9io25b31YzxwYiat0Kx5PJnQjvnfK109EJOauKx6RZSK3egJLrchSVtkWQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac000b085b0c9d-EWR
+      - 8ab6b640db0fc46d-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
-      string: '{"total":621,"jobPostings":[{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby,
-        UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48791","Rugby, UK
-        (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby,
-        UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48793","Rugby, UK
-        (ZUK107)"]},{"title":"Senior Technical Support Engineer (Edesix Mobile Video
-        APAC Region)","externalPath":"/job/Penang-Malaysia/Senior-Technical-Support-Engineer--Edesix-Mobile-Video-APAC-Region-_R48950","locationsText":"Penang,
-        Malaysia","postedOn":"Posted Today","bulletFields":["R48950","Penang, Malaysia
-        (ZMY33)"]},{"title":"Systems Integrations and Tests Engineer","externalPath":"/job/Krakow-Poland/Systems-Integrations-and-Tests-Engineer_R48671","locationsText":"Krakow,
-        Poland","postedOn":"Posted Today","bulletFields":["R48671","Krakow, Poland"]},{"title":"Senior
-        UX Designer","externalPath":"/job/Krakow-Poland/Senior-UX-Designer_R47040-1","locationsText":"Krakow,
-        Poland","postedOn":"Posted Today","bulletFields":["R47040","Krakow, Poland"]},{"title":"Software
-        Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48528","locationsText":"Bangalore,
-        India","postedOn":"Posted Today","bulletFields":["R48528","Bangalore, India
-        (ZIN110)"]},{"title":"Software Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48521","locationsText":"Bangalore,
-        India","postedOn":"Posted Today","bulletFields":["R48521","Bangalore, India
-        (ZIN110)"]},{"title":"SOC Analyst","externalPath":"/job/Schaumburg-IL/SOC-Analyst_R48874","locationsText":"Schaumburg,
-        IL","postedOn":"Posted Yesterday","bulletFields":["R48874","Schaumburg, IL
-        (IL01)"]},{"title":"Technical Triage Supervisor","externalPath":"/job/Reynosa-Mexico/Technical-Triage-Supervisor_R47739","locationsText":"Reynosa,
-        Mexico","postedOn":"Posted 3 Days Ago","bulletFields":["R47739","Reynosa,
-        Mexico (ZMX70)"]},{"title":"Senior Sales Engineer","externalPath":"/job/Pennsylvania-US-Offsite/Senior-Sales-Engineer_R48701","locationsText":"Pennsylvania,
-        US Offsite, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48701","Pennsylvania,
-        US Offsite (PA999)"]},{"title":"Director of Procurement","externalPath":"/job/Greater-Chicago-Area/Director-of-Procurement_R48891","locationsText":"Greater
-        Chicago Area, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48891","Greater
-        Chicago Area"]},{"title":"NOC Agent I","externalPath":"/job/Santiago-Chile/NOC-Agent-I_R48421","locationsText":"Santiago,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48421","Santiago,
-        Chile (ZCE10)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48725","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48725","Calama, Chile
-        (ZCE17)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48730","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48730","Calama, Chile
-        (ZCE17)"]},{"title":"Tecnico Instalador RF","externalPath":"/job/Calama-Chile/Tecnico-Instalador-RF_R48729","locationsText":"Calama,
-        Chile","postedOn":"Posted 3 Days Ago","bulletFields":["R48729","Calama, Chile
-        (ZCE17)"]},{"title":"Portfolio Team Director","externalPath":"/job/Schaumburg-IL/Portfolio-Team-Director_R48414","locationsText":"Schaumburg,
-        IL, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48414","Schaumburg,
-        IL (IL01)"]},{"title":"Project Manager - Northeast Region Software Deployment
-        - US Remote","externalPath":"/job/New-Jersey-Remote-Work/Project-Manager---Northeast-Region-Software-Deployment---US-Remote_R48926","locationsText":"New
-        Jersey Remote Work, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48926","New
-        Jersey Remote Work"]},{"title":"Sales Manager","externalPath":"/job/Colorado-Remote-Work/Sales-Manager_R48640","locationsText":"Colorado
-        Remote Work","postedOn":"Posted 3 Days Ago","bulletFields":["R48640","Colorado
-        Remote Work"]},{"title":"Data Protection, Product Compliance Specialist -
-        Legal Support (US Remote)","externalPath":"/job/Chicago-IL/Data-Protection--Product-Compliance-Specialist---Legal-Support--US-Remote-_R48911-1","locationsText":"Chicago,
-        IL, More...","postedOn":"Posted 3 Days Ago","bulletFields":["R48911","Chicago,
-        IL (IL156)"]},{"title":"Quality Software Assurance Engineer","externalPath":"/job/Plantation-FL/Quality-Software-Assurance-Engineer_R48284","locationsText":"Plantation,
-        FL","postedOn":"Posted 3 Days Ago","bulletFields":["R48284","Plantation, FL
-        (FL08)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job
-        Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":294},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":89},{"descriptor":"Service
-        & Support","id":"c2197eea2758408bbbe52d2c04006230","count":81},{"descriptor":"Manufacturing
-        & Supply Chain","id":"5a650a685cb64a0ba694baa053e24bda","count":36},{"descriptor":"Information
-        Technology","id":"c3fc17b768e842e39b7192f0bf4cb0f1","count":32},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":28},{"descriptor":"Professional
-        Services","id":"60d771b675b201093e19718f600171af","count":18},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":17},{"descriptor":"General
-        Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":14},{"descriptor":"Administration
-        & Facilities","id":"0191c22da3ac417c94d450ccdb06a7ed","count":5},{"descriptor":"Legal
-        & Regulatory","id":"4170777a1c914320ad8828c0ec033c53","count":4},{"descriptor":"Human
-        Resources","id":"8e651d1131bc4aad9a089b555adc3975","count":3}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"North
-        America","id":"436f05d7afa343d5a8c9f92ef3e8c71b","count":187},{"descriptor":"Asia
-        Pacific","id":"14bb6aa2c25e4a218b2a3faaa951e44c","count":140},{"descriptor":"Europe
-        Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":116},{"descriptor":"Latin
-        America","id":"d6565dafd0ce4473932b0ce1ce9a0307","count":22}]},{"facetParameter":"timeType123","descriptor":"Time
-        Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":615},{"descriptor":"Part
-        time","id":"43259991a4cc42f1a7570dd5dc911e13","count":6}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":8},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":19},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":24},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":64},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":60},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":5},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":2},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":96},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":9},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Saudi
-        Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Taiwan","id":"a4e08b475d6a4176853c9d1cb9854e02","count":1},{"descriptor":"United
-        Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"United
-        Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":35},{"descriptor":"United
-        States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":227},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"Adelaide,
-        Australia","id":"84a18dcbc0d5453081ff0257c1ddc017","count":1},{"descriptor":"Alabama,
-        US Offsite","id":"bbb70e9710004203b5c0165259b19722","count":1},{"descriptor":"Alabama
-        Remote Work","id":"a2aa2501ee340139269db5448422f90a","count":2},{"descriptor":"Alberta
-        Remote Work","id":"a2aa2501ee3401ebad8800458422350b","count":2},{"descriptor":"Albuquerque,
-        NM (NM06)","id":"726d9bb69ca00184bc0a4eeaae18a9a7","count":2},{"descriptor":"Allen,
-        TX (TX139)","id":"a2aa2501ee340194a7e124312b23666e","count":22},{"descriptor":"Antofagasta,
-        Chile","id":"ff21797042291056c2292e32bd504b2e","count":1},{"descriptor":"Argentina
-        Offsite (ZAR99)","id":"5b4156247dd945009ecdd0815cc32261","count":2},{"descriptor":"Arizona,
-        US Offsite","id":"1427da907f71482e93d2ca9a94f4a721","count":19},{"descriptor":"Arizona
-        Remote Work","id":"a2aa2501ee3401172758a8448422ef0a","count":14},{"descriptor":"Arkansas
-        Remote Work","id":"a2aa2501ee340168512097448422e00a","count":1},{"descriptor":"Atlanta,
-        GA","id":"e6754dd8376744ae8810143cfdbd586b","count":1},{"descriptor":"Austria
-        Offsite (ZAT99)","id":"22cd4ef36d4410e861598876a5d8cdbe","count":2},{"descriptor":"Bangalore,
-        India","id":"dc87e0de602f103e7f08db009e1c78c9","count":54},{"descriptor":"Bangalore,
-        India (ZIN114)","id":"4114a9c5ddc5010679785ea9e8011a38","count":5},{"descriptor":"Bangalore
-        offsite, India","id":"83e4449f1df80133688024551401456f","count":3},{"descriptor":"Bay
-        Shore, NY (NY54)","id":"d879770ce580100165639203abdb0000","count":6},{"descriptor":"Beltsville,
-        MD","id":"ec2584050ebf102fb4ed7d77e3a0219e","count":5},{"descriptor":"Berlin,
-        Germany (ZWG172)","id":"da1bb7b30412011d12861db1754a47e2","count":4},{"descriptor":"Birmingham,
-        AL","id":"37cbf3aa4d9810d6aa793a34d460121d","count":1},{"descriptor":"Bogota,
-        Colombia (ZCL04)","id":"4e4bade28097445dbdf1e9acd5883db8","count":2},{"descriptor":"Brazil
-        Offsite","id":"31e50f098c28482282d16915b1f03b02","count":1},{"descriptor":"Brazil
-        Remote Work","id":"a2aa2501ee3401046547064584223a0b","count":14},{"descriptor":"British
-        Columbia,CAN Offsite","id":"99abf5d326b8405d913f070afd962314","count":2},{"descriptor":"British
-        Columbia Remote Work","id":"a2aa2501ee3401529baefa448422300b","count":2},{"descriptor":"Buenos
-        Aires, Ar - bus cntr (ZAR20)","id":"82f5b0bf5d18014fe0aa2c9b8f01e376","count":2},{"descriptor":"Bulgaria
-        Offsite (ZBU99)","id":"b20e212a792d4ebba04149117d379262","count":3},{"descriptor":"Burswood,
-        Australia","id":"315987c1b99841a2a788d8e7f09c3e85","count":1},{"descriptor":"Cairo,
-        Egypt","id":"27419f4f50f31074bf6d12933928093d","count":1},{"descriptor":"Calama,
-        Chile","id":"5add0ac80d6801f6eb698aeb780d6d24","count":3},{"descriptor":"California
-        Northern, US Offsite","id":"51094660fa0a4ec4b328886f73a854d2","count":5},{"descriptor":"California
-        Northern Remote Work","id":"a2aa2501ee34015666cf5f448422b30a","count":11},{"descriptor":"California
-        Southern, US Offsite","id":"2e27a5a31dfb43d6b1fe21b8f268733c","count":6},{"descriptor":"California
-        Southern Remote Work","id":"a2aa2501ee34016f686b59448422ae0a","count":13},{"descriptor":"Charlotte,
-        NC","id":"09f65edec644100fb96d7a9a30a7de0e","count":1},{"descriptor":"Chicago,
-        IL","id":"56b899ac82d3102ebb10086c343f0eed","count":44},{"descriptor":"Chile
-        Remote Work","id":"a2aa2501ee340133264bcf4484220d0b","count":1},{"descriptor":"Colorado,
-        US Offsite","id":"14ab7340d6e645c1827628a28827563a","count":1},{"descriptor":"Colorado
-        Remote Work","id":"a2aa2501ee34015a1230464484229f0a","count":9},{"descriptor":"Connecticut,
-        US Offsite","id":"399e74c7d2c4436ea401e45369f54a9c","count":3},{"descriptor":"Connecticut
-        Remote Work","id":"a2aa2501ee3401d887c339448422950a","count":2},{"descriptor":"Cork,
-        Ireland","id":"61b9ddf3a0c51000b136358fdbcb0000","count":1},{"descriptor":"Cork,
-        Ireland - Business CNTR (ZEI16)","id":"e8aed7fb96be1000b4bd44c6150c0000","count":29},{"descriptor":"Culver
-        City, CA","id":"f2cb61a1d06a01e3044baadd1f01ba77","count":7},{"descriptor":"Dallas,
-        TX","id":"d0be8406d7eb0108618092b78c8c3d7d","count":3},{"descriptor":"Dallas,
-        TX (TX143)","id":"61b9ddf3a0c51000b1184fb114ed0000","count":1},{"descriptor":"Delaware,
-        US Offsite","id":"fdbba75aa4044c649cf4ddd888004e1e","count":8},{"descriptor":"Delaware
-        Remote Work","id":"a2aa2501ee3401860b4433448422900a","count":5},{"descriptor":"Dubai,
-        UAE","id":"7dda71e222860100aa71137f4c680000","count":2},{"descriptor":"Eagan,
-        MN","id":"45632196659f01ded4d69952ac36dd7a","count":1},{"descriptor":"Edinburgh,
-        UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Elgin,
-        IL","id":"56b899ac82d3102ebe1e9ed8fc6722d7","count":1},{"descriptor":"Farmington
-        Hills, MI (MI17)","id":"da1bb7b3041201d56bf55c9f774a95e3","count":1},{"descriptor":"Florida,
-        US Offsite","id":"024e19ecdef743ea8576fd1f592a479c","count":22},{"descriptor":"Florida
-        Remote Work","id":"a2aa2501ee34015d6ddb26478422fd0c","count":24},{"descriptor":"Fornebu,
-        Norway (ZNO11)","id":"ba927ad987ee01020389e6b494000000","count":1},{"descriptor":"Fort
-        Collins, CO (CO29)","id":"4114a9c5ddc501787dea77fde7019936","count":2},{"descriptor":"Fort
-        Worth, TX (TX135)","id":"731a6d25b4bc01260a2ef4efbe0b4e60","count":2},{"descriptor":"Framingham,
-        MA","id":"442a24924422100157ed1e5a4c5c0000","count":1},{"descriptor":"Fresno,
-        CA (CA180)","id":"4114a9c5ddc501232fd3ac42e7010636","count":2},{"descriptor":"Ft.
-        Lauderdale, FL (FL87)","id":"da5e91a4328101abe15bda8ec823a9bc","count":2},{"descriptor":"Georgia,
-        US Offsite","id":"f1180d181cc140dba59dd0e993a002f1","count":14},{"descriptor":"Georgia
-        Remote Work","id":"a2aa2501ee3401b67a9904478422df0c","count":14},{"descriptor":"Germany
-        Offsite (ZWG99)","id":"5c1aee55369b44a2a5136da8dec8e315","count":6},{"descriptor":"Glasgow,
-        UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Glostrup,
-        Denmark (ZDK02)","id":"27a1c404f5744ae68442996960fe2804","count":3},{"descriptor":"Greater
-        Chicago Area","id":"a2aa2501ee34015128ebf2468422d00c","count":15},{"descriptor":"Greater
-        Dallas Area","id":"a2aa2501ee34013ba7b67b4584229a0b","count":1},{"descriptor":"Greater
-        Krakow Area","id":"a2aa2501ee3401e68a4c96478422610d","count":1},{"descriptor":"Gurgaon,
-        India","id":"d879770ce5801001ba2441f0f8260000","count":4},{"descriptor":"Hemel
-        Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1},{"descriptor":"Ho
-        Chi Minh, Vietnam","id":"04fbb808deef1000aba4980e9ce60000","count":2},{"descriptor":"Ho
-        Chi Minh City, Vietnam (ZVI16)","id":"da5e91a4328101b8bd368cee2324adf1","count":1},{"descriptor":"Idaho
-        Remote Work","id":"a2aa2501ee3401e0c730f9468422d50c","count":2},{"descriptor":"Idstein,
-        Germany (ZWG86)","id":"04a42199937044bbbf6010ed72d1d007","count":2},{"descriptor":"Illinois,
-        US Offsite","id":"037ebcbfd6ee4ad8a96ca2f9ec955366","count":33},{"descriptor":"Illinois
-        Remote Work","id":"a2aa2501ee3401b4149aec468422cb0c","count":28},{"descriptor":"Indiana,
-        US Offsite","id":"86ac456645c1476581ccafcdabd07091","count":10},{"descriptor":"Indianapolis,
-        IN","id":"7f977422e7ba456a98281fb6d502202e","count":1},{"descriptor":"Indiana
-        Remote Work","id":"a2aa2501ee3401181c56e6468422c60c","count":15},{"descriptor":"India
-        Offsite (ZIN99)","id":"801ee26ff10b4e2389d3a9d125e02ae3","count":2},{"descriptor":"Iowa,
-        US Offsite","id":"1787eed6fea6446f9bc1036e9a5962d9","count":1},{"descriptor":"Iowa
-        Remote Work","id":"a2aa2501ee34012b9d0fda468422bc0c","count":7},{"descriptor":"Italy
-        Offsite (ZIT99)","id":"7de50b13083047dfb5400de1b3b32aba","count":1},{"descriptor":"Kansas,
-        US Offsite","id":"061f9780eeaf4ab392eb38562e8635c0","count":4},{"descriptor":"Kansas
-        Remote Work","id":"a2aa2501ee3401a115bcd4468422b70c","count":5},{"descriptor":"Kentucky,
-        US Offsite","id":"5e9d2bcbc1df436db79c28a492f83838","count":2},{"descriptor":"Kentucky
-        Remote Work","id":"a2aa2501ee340110c46bcf468422b20c","count":2},{"descriptor":"Krakow,
-        Poland","id":"cdb6c301cead01c0fd6255fbbe0073b9","count":90},{"descriptor":"Krakow,
-        Poland","id":"30c4e7f824bd4b1a892b4ee4a537c2f7","count":2},{"descriptor":"Krakow,
-        Poland","id":"3cc51f087f9747d5b0b2af9d001b0281","count":1},{"descriptor":"Kuala
-        Lumpur, Malaysia","id":"817fef2f26ad4eec85f3d1f59f67a08c","count":2},{"descriptor":"Lexington,
-        SC (SC07)","id":"da5e91a43281017cec012a9ab8239ba2","count":1},{"descriptor":"Linthicum,
-        MD","id":"c152d08a5f9c104eed32617c8087529c","count":3},{"descriptor":"Lisbon,
-        Portugal","id":"d0be8406d7eb01df5699f9468d8cf97d","count":8},{"descriptor":"Lisbon,
-        Portugal","id":"60d771b675b201dd1b8cf4a90e01c534","count":1},{"descriptor":"Little
-        Rock, AR","id":"9294dc0527c54192b5c8338f762402d1","count":1},{"descriptor":"London,
-        UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":4},{"descriptor":"Los
-        Angeles, CA","id":"75eeec0cd30c4823b7cdbc46c87436e3","count":1},{"descriptor":"Los
-        Angeles, CA","id":"20b991fa96e9475db727dbe3c7df1156","count":1},{"descriptor":"Louisiana
-        Remote Work","id":"a2aa2501ee340134851ac4468422a80c","count":1},{"descriptor":"Madrid,
-        Spain","id":"8cfc0951b3b94bd98139c963eb68ec99","count":2},{"descriptor":"Maine,
-        US Offsite","id":"992c04fd1a9c41d3a6a904ffe0de680c","count":3},{"descriptor":"Maine
-        Remote Work","id":"a2aa2501ee34019d8ee2b74684229e0c","count":5},{"descriptor":"Manitoba
-        Remote Work","id":"a2aa2501ee3401b8f6e9f44484222b0b","count":3},{"descriptor":"Maryland,
-        US Offsite","id":"b83767d4324c46c999f575fd542abd88","count":16},{"descriptor":"Maryland
-        Remote Work","id":"a2aa2501ee3401dbf94bb2468422990c","count":18},{"descriptor":"Massachusetts,
-        US Offsite","id":"ef9ff0866473431aa0807077edea046d","count":18},{"descriptor":"Massachusetts
-        Remote Work","id":"a2aa2501ee340136dff99f4684228a0c","count":12},{"descriptor":"Melbourne,
-        Australia","id":"d7e3ba3b107b442382576d564fcbadfd","count":2},{"descriptor":"Mexico
-        City, Mexico","id":"2b254088ddb54694997bd94b011e140c","count":4},{"descriptor":"Mexico
-        Offsite","id":"5ef0f2a16491016a2dbdefc5034f5d9c","count":1},{"descriptor":"Michigan,
-        US Offsite","id":"4b3514833681469ba0b512c446b25b97","count":10},{"descriptor":"Michigan
-        Remote Work","id":"a2aa2501ee3401621d8898468422830c","count":9},{"descriptor":"Minnesota,
-        US Offsite","id":"efb7395e01e54bde949ac224af8f56a6","count":3},{"descriptor":"Minnesota
-        Remote Work","id":"a2aa2501ee34018daff981468422740c","count":5},{"descriptor":"Mississippi
-        Remote Work","id":"a2aa2501ee340143de0a7c4684226f0c","count":2},{"descriptor":"Missouri,
-        US Offsite","id":"fb75ff372ac14e1b809a1dd53333021e","count":2},{"descriptor":"Missouri
-        Remote Work","id":"a2aa2501ee340123e99d6f468422650c","count":4},{"descriptor":"Montana
-        Remote Work","id":"a2aa2501ee3401c92dfa69468422600c","count":1},{"descriptor":"Morocco
-        Offsite (ZMO99)","id":"13183554e71d4ea3b51cc01fb4310a38","count":1},{"descriptor":"Muscat,
-        Oman","id":"7af2294c87014d38b73cc1f8e8046db2","count":1},{"descriptor":"Nebraska
-        Remote Work","id":"a2aa2501ee3401c3ed27644684225b0c","count":1},{"descriptor":"Nevada,
-        US Offsite","id":"63ba34e24ce44a5d92912e0cadae491c","count":1},{"descriptor":"Nevada
-        Remote Work","id":"a2aa2501ee34015e595a5e468422560c","count":2},{"descriptor":"New
-        Hampshire, US Offsite","id":"0727cec59d1544888ff072b50e96a1c3","count":5},{"descriptor":"New
-        Hampshire Remote Work","id":"a2aa2501ee3401e10a2558468422510c","count":3},{"descriptor":"Newington,
-        VA","id":"a2d68824ae0f4fdfa99ac487376a60c0","count":1},{"descriptor":"New
-        Jersey, US Offsite","id":"dd456a04291641a5b02b5731f3e70d4a","count":9},{"descriptor":"New
-        Jersey Remote Work","id":"a2aa2501ee340154abd2524684224c0c","count":14},{"descriptor":"New
-        Mexico, US Offsite","id":"0bf30a8368014b0e90cd36a3c4d20e1a","count":2},{"descriptor":"New
-        Mexico Remote Work","id":"a2aa2501ee3401cff79a46468422420c","count":3},{"descriptor":"New
-        York, US Offsite","id":"3f76dd361d8b410784ca4fc8dc2421f7","count":8},{"descriptor":"New
-        York Remote Work","id":"a2aa2501ee34015fb0b438468422380c","count":11},{"descriptor":"North
-        Carolina, US Offsite","id":"2080bb98030b4515ba37427d91ff32cc","count":13},{"descriptor":"North
-        Carolina Remote Work","id":"a2aa2501ee34015223b220468422210c","count":15},{"descriptor":"North
-        Dakota, US Offsite","id":"a9996a2fd97f4d3e95a330c9526ec0b3","count":1},{"descriptor":"North
-        Dakota Remote Work","id":"a2aa2501ee3401842df90e468422120c","count":3},{"descriptor":"NSW
-        Offsite, Australia","id":"8e1edfbe285b1063341996ac3138c4ca","count":1},{"descriptor":"Offsite
-        France (ZFR99)","id":"71f31ba331b642f3a3ae05b211a469d1","count":1},{"descriptor":"Ohio,
-        US Offsite","id":"c9f53b4342e94035b77570cfe5599af6","count":15},{"descriptor":"Ohio
-        Remote Work","id":"a2aa2501ee34011ff5ccfc458422030c","count":12},{"descriptor":"Oklahoma,
-        US Offsite","id":"7ceb761aa15d46d7b6c9a6bb4d05c509","count":4},{"descriptor":"Oklahoma
-        Remote Work","id":"a2aa2501ee3401d33bbaf6458422fe0b","count":4},{"descriptor":"ONT39","id":"5c4e189f92a610016f2ffc6e5c630000","count":3},{"descriptor":"Ontario
-        Remote Work","id":"a2aa2501ee340179e5f7e8448422210b","count":10},{"descriptor":"Oregon,
-        US Offsite","id":"746c5cc1f07d48d7837f3db4895a18e7","count":9},{"descriptor":"Oregon
-        Remote Work","id":"a2aa2501ee3401d4d45ff0458422f90b","count":5},{"descriptor":"Orlando,
-        FL","id":"b7c95ddf5a041015a61c88e160676351","count":2},{"descriptor":"Oslo,
-        Norway (ZNO07)","id":"8ef71253a56d4aaf92ff5a5364ccc8ac","count":1},{"descriptor":"Ottawa,
-        Canada","id":"77e555f21e5501db407373e92a70fa79","count":1},{"descriptor":"Parma,
-        OH","id":"9efafca5ae9041f7980582836384f807","count":1},{"descriptor":"Penang,
-        Malaysia","id":"c6d7e2b64f8b107f215186f1d658a224","count":58},{"descriptor":"Penang,
-        Malaysia","id":"8dfc527f8ed44cee87fe36c1afbaf264","count":1},{"descriptor":"Penang,
-        Malaysia","id":"168b0d8a3214463583f95156388faf2d","count":1},{"descriptor":"Pennsylvania,
-        US Offsite","id":"89941ac3741f436ab4e333e49a8fba84","count":16},{"descriptor":"Pennsylvania
-        Remote Work","id":"a2aa2501ee3401fe0c4ed8458422e50b","count":12},{"descriptor":"Plantation,
-        FL","id":"17ba885223814f9ab57dedd1e725b00a","count":8},{"descriptor":"Plantation,
-        FL","id":"d879770ce5801001b9b947c3860f0000","count":1},{"descriptor":"Poland
-        Offsite (ZPL99)","id":"9587715495c14b2b946ee753f5adba22","count":8},{"descriptor":"Portugal
-        Offsite (ZPT99)","id":"22e48e01af704af5acf68a768e1184ed","count":1},{"descriptor":"Puerto
-        Rico Offsite","id":"c35e2c7bf9b1444bb4c00699df114d76","count":1},{"descriptor":"Quebec
-        Remote Work","id":"a2aa2501ee34017ab529dc448422170b","count":6},{"descriptor":"Reynosa,
-        Mexico","id":"2cc4589d2ab01001021366bdbd430000","count":1},{"descriptor":"Rhode
-        Island, US Offsite","id":"75ccaab07ff843b4bb5433ed70cbaff7","count":4},{"descriptor":"Rhode
-        Island Remote Work","id":"a2aa2501ee34018f99a6c6458422d60b","count":1},{"descriptor":"Richardson,
-        TX (TX141)","id":"a1b4b9c5b61b016ad44e1b6108028e25","count":1},{"descriptor":"Richmond,
-        VA","id":"9ea53914b84d01586593035807010e1b","count":1},{"descriptor":"Riyadh,
-        Saudi Arabia","id":"dfff2595c3404fe89fcea0c4a139065c","count":2},{"descriptor":"Romania
-        Offsite (ZRO99)","id":"88268c4ae43b48c1bd5baa7007a31a71","count":1},{"descriptor":"Rugby,
-        UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Sacramento,
-        CA","id":"c4ee93d3538249b29c9fb0bfde3295be","count":1},{"descriptor":"San
-        Mateo, CA","id":"3955e91ab9be1000d6a5f34dfd560000","count":1},{"descriptor":"Santiago,
-        Chile","id":"ff21797042291056c1ed919d43474a6f","count":2},{"descriptor":"Santiago,
-        Chile","id":"ff21797042291056c2a0d44e6f564d8b","count":1},{"descriptor":"Sao
-        Paulo, Brazil","id":"d234454abe5110015dd3a0c5bb570000","count":4},{"descriptor":"Sarasota,
-        FL","id":"279a8a3ddd4d018ef74c6ecba500157e","count":1},{"descriptor":"Saskatchewan
-        Remote Work","id":"a2aa2501ee34019300f5d5448422120b","count":3},{"descriptor":"Schaumburg,
-        IL","id":"5983637b827e4ed097966aa984c7cf6c","count":9},{"descriptor":"Schaumburg,
-        IL","id":"f90bd5bcf3df4205a301db42c4557bdd","count":1},{"descriptor":"Schio,
-        Italy","id":"a66ea95a586801014b0a39c8aa730000","count":1},{"descriptor":"Singapore,
-        Singapore","id":"914a4f61913c10357f56e7fd0de4f904","count":1},{"descriptor":"Singapore,
-        Singapore (ZSG38)","id":"c6d7e2b64f8b107f233884cad328a5a5","count":1},{"descriptor":"Somerville,
-        MA","id":"d0be8406d7eb01197d6786d18c8c617d","count":2},{"descriptor":"South
-        Carolina, US Offsite","id":"4548f2167eca45daaa61d7c4aa7d08da","count":2},{"descriptor":"South
-        Carolina Remote Work","id":"a2aa2501ee3401ac594eb9458422cc0b","count":10},{"descriptor":"South
-        Dakota, US Offsite","id":"520ca850ee1443438ff88ea729c5dc1f","count":1},{"descriptor":"South
-        Dakota Remote Work","id":"a2aa2501ee3401e9b731b3458422c70b","count":2},{"descriptor":"Spain
-        Offsite (ZES99)","id":"301a357729b94516a34e3a61a35c1bb5","count":1},{"descriptor":"St.
-        Petersburg, FL (FL92)","id":"4114a9c5ddc501b041023c10a301a7b6","count":1},{"descriptor":"Sterling,
-        VA","id":"ca833823055501ee67c0d0e6ff01d6ee","count":1},{"descriptor":"St Petersburg,
-        FL","id":"b9d0a434256f01442efa8db524cf8e23","count":1},{"descriptor":"Switzerland
-        Offsite (ZSW99)","id":"bc6c8eecc49e4078ac65cd83165d02c5","count":1},{"descriptor":"Sydney,
-        Australia (ZAS102)","id":"a161ce532f951001110b54a8d1f80000","count":1},{"descriptor":"Taguig,
-        Philippines","id":"c6c7d41a752501ed42def116f4000e0e","count":2},{"descriptor":"Taipei,
-        Taiwan (ZTW27)","id":"d5ae1f500ea90178bf268aa77a2ef6bc","count":1},{"descriptor":"Tennessee,
-        US Offsite","id":"aa9f12002a984c16858ff0b2be54fce4","count":14},{"descriptor":"Tennessee
-        Remote Work","id":"a2aa2501ee3401a15dcfac458422c20b","count":13},{"descriptor":"Texas,
-        US Offsite","id":"7951f208c4a44af291de95d7063ca8ea","count":33},{"descriptor":"Texas
-        Remote Work","id":"a2aa2501ee3401bb3ac08d458422a90b","count":25},{"descriptor":"Tokyo,
-        Japan","id":"8c4c7f50760701262d4b1accf800fb4f","count":1},{"descriptor":"Toronto,
-        Canada (ONT40)","id":"442a249244221001582c47e270eb0000","count":6},{"descriptor":"United
-        Arab Emirates Offsite (ZUA99)","id":"dcc3bd6cdddc4454ad3336c2520953a5","count":1},{"descriptor":"United
-        Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":21},{"descriptor":"Utah,
-        US Offsite","id":"f61b91f41da34642ae840d013eb6ec7d","count":18},{"descriptor":"Utah
-        Remote Work","id":"a2aa2501ee3401463afc6e458422900b","count":10},{"descriptor":"Uxbridge,
-        UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Vancouver,
-        Canada","id":"d0be8406d7eb01e1ef6d1c418c8cf679","count":7},{"descriptor":"Vermont
-        Remote Work","id":"a2aa2501ee3401d6729461458422840b","count":3},{"descriptor":"Versailles,
-        France","id":"7dda71e222860100ab254c24897f0000","count":1},{"descriptor":"Vienna,
-        Austria","id":"46a2113a7c421062bd06fb72dee26f45","count":1},{"descriptor":"Virginia,
-        US Offsite","id":"c6987245ed6b4552b729aa8ca40c084f","count":16},{"descriptor":"Virginia
-        Remote Work","id":"a2aa2501ee3401aefdf55a4584227f0b","count":12},{"descriptor":"Ware,
-        UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Warsaw,
-        Poland","id":"d4e8b75046371067ca56ac231068e8e9","count":2},{"descriptor":"Warsaw,
-        Poland","id":"c3422e7a11fd466e8a10d70edc3171ce","count":2},{"descriptor":"Washington,
-        US Offsite","id":"0270f0ddaa9c4df780efe79b9477a4dc","count":5},{"descriptor":"Washington
-        DC, US Offsite","id":"6703b0349e294f7982d1105b4180e6bf","count":4},{"descriptor":"Washington
-        DC Remote Work","id":"a2aa2501ee34012ca4a4274484228b0a","count":6},{"descriptor":"Washington
-        Remote Work","id":"a2aa2501ee3401c3bf02344584225d0b","count":9},{"descriptor":"Westminster,
-        CO","id":"435c641825b8436a950f0c3c604cc62e","count":1},{"descriptor":"West
-        Valley City, UT","id":"dc4b44bb9c9210367f2102c8f37b8c34","count":1},{"descriptor":"West
-        Virginia, US Offsite","id":"41c94f5726b54db19a40ed8ab4c7016f","count":1},{"descriptor":"West
-        Virginia Remote Work","id":"a2aa2501ee3401a5c1d62d458422580b","count":3},{"descriptor":"Wisconsin,
-        US Offsite","id":"e350deb449e548d7be5c7185f399be05","count":2},{"descriptor":"Wisconsin
-        Remote Work","id":"a2aa2501ee340159152027458422530b","count":10},{"descriptor":"Woodcliff
-        Lake, NJ","id":"56b899ac82d3102ebddb9e5d99cf2205","count":1},{"descriptor":"Wyoming,
-        US Offsite","id":"857b68215cb8413f8fc0085cc2df67b3","count":1},{"descriptor":"Wyoming
-        Remote Work","id":"a2aa2501ee3401412f02214584224e0b","count":4},{"descriptor":"ZAS100","id":"20a50c646bd31001a8ec21fd6d5f0000","count":2}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10
-        miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25
-        miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50
-        miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100
-        miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any
-        Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}'
-  recorded_at: Mon, 29 Jul 2024 09:14:42 GMT
+      string: !binary |-
+        {"total":622,"jobPostings":[{"title":"Business and Data Analytics - 2024 Fall Co-Op","externalPath":"/job/Allen-TX-TX139/Business-and-Data-Analytics---2024-Fall-Co-Op_R48967","locationsText":"Allen, TX (TX139)","postedOn":"Posted Today","bulletFields":["R48967","Allen, TX (TX139)"]},{"title":"Channel Sales Executive - Video Security & Access Control (Dallas)","externalPath":"/job/Dallas-TX/Channel-Sales-Executive---Video-Security---Access-Control--Dallas-_R48932","locationsText":"Dallas, TX, More...","postedOn":"Posted Today","bulletFields":["R48932","Dallas, TX (TX133)"]},{"title":"VS&A Product Sales Specialist - Pelco (Southeast)","externalPath":"/job/Ft-Lauderdale-FL-FL87/VS-A-Product-Sales-Specialist---Pelco--Southeast-_R48680-1","locationsText":"Ft. Lauderdale, FL (FL87), More...","postedOn":"Posted Today","bulletFields":["R48680","Ft. Lauderdale, FL (FL87)"]},{"title":"VS&A Product Sales Specialist - Pelco (Northeast)","externalPath":"/job/Framingham-MA/VS-A-Product-Sales-Specialist---Pelco--Northeast-_R48679-1","locationsText":"Framingham, MA, More...","postedOn":"Posted Today","bulletFields":["R48679","Framingham, MA (MA52)"]},{"title":"VS&A Product Sales Specialist - Pelco (West)","externalPath":"/job/Phoenix-AZ/VS-A-Product-Sales-Specialist---Pelco--West-_R48678-1","locationsText":"Phoenix, AZ, More...","postedOn":"Posted Today","bulletFields":["R48678","Phoenix, AZ (AZ93)"]},{"title":"VS&A Product Sales Specialist - Pelco (Central)","externalPath":"/job/Illinois-US-Offsite/VS-A-Product-Sales-Specialist---Pelco--Central-_R48677-1","locationsText":"Illinois, US Offsite, More...","postedOn":"Posted Today","bulletFields":["R48677","Illinois, US Offsite (IL999)"]},{"title":"Software Developer","externalPath":"/job/Bangalore-offsite-India/Software-Developer_R48966","locationsText":"Bangalore offsite, India","postedOn":"Posted Today","bulletFields":["R48966","Bangalore offsite, India (ZIN125)"]},{"title":"Avigilon Business Development Manager, A&E , West Region","externalPath":"/job/California-Northern-Remote-Work/Avigilon-Business-Development-Manager--A-E---West-Region_R48885","locationsText":"California Northern Remote Work, More...","postedOn":"Posted Today","bulletFields":["R48885","California Northern Remote Work"]},{"title":"Junior Order Management Coordinator (mixed shift)","externalPath":"/job/Krakow-Poland/Junior-Order-Management-Coordinator--mixed-shift-_R48896","locationsText":"Krakow, Poland","postedOn":"Posted Today","bulletFields":["R48896","Krakow, Poland"]},{"title":"Responsable support client / Customer Support Manager","externalPath":"/job/Versailles-France/Customer-Support-Manager_R48390","locationsText":"Versailles, France","postedOn":"Posted Today","bulletFields":["R48390","Versailles, France (ZFR49)"]},{"title":"Solutions Architect (US REMOTE)","externalPath":"/job/Colorado-Remote-Work/Sr-Solutions-Architect--US-REMOTE-_R48655","locationsText":"Colorado Remote Work, More...","postedOn":"Posted Today","bulletFields":["R48655","Colorado Remote Work"]},{"title":"Manager Software Engineering","externalPath":"/job/Bangalore-India/Manager-Software-Engineering_R47328","locationsText":"Bangalore, India","postedOn":"Posted Today","bulletFields":["R47328","Bangalore, India (ZIN110)"]},{"title":"Estágio em Gerenciamento de Projetos","externalPath":"/job/Sao-Paulo-Brazil/Estgio-em-Gerenciamento-de-Projetos_R48964","locationsText":"Sao Paulo, Brazil","postedOn":"Posted Today","bulletFields":["R48964","Sao Paulo, Brazil (ZBR48)"]},{"title":"Junior Systems Engineer","externalPath":"/job/Lisbon-Portugal/Junior-Systems-Engineer_R48482","locationsText":"Lisbon, Portugal","postedOn":"Posted Today","bulletFields":["R48482","Lisbon, Portugal (ZPT16)"]},{"title":"Software Engineer","externalPath":"/job/Bangalore-India/Software-Engineer_R48827","locationsText":"Bangalore, India","postedOn":"Posted Today","bulletFields":["R48827","Bangalore, India (ZIN110)"]},{"title":"Senior Electrical Engineer (RF)","externalPath":"/job/Penang-Malaysia/Senior-Electrical-Engineer--RF-_R45891","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R45891","Penang, Malaysia (ZMY33)"]},{"title":"Software Engineer","externalPath":"/job/Penang-Malaysia/Software-Engineer_R48238","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R48238","Penang, Malaysia (ZMY33)"]},{"title":"Quality Specialist","externalPath":"/job/ZAS100/Quality-Specialist_R46952-1","locationsText":"ZAS100","postedOn":"Posted Today","bulletFields":["R46952","Perth, Australia (ZAS100)"]},{"title":"Senior Field Service Support Engineer","externalPath":"/job/Seoul-Korea/Senior-Field-Service-Support-Engineer_R48271","locationsText":"Seoul, Korea","postedOn":"Posted Today","bulletFields":["R48271","Seoul, Korea (ZKR44)"]},{"title":"Software Engineer","externalPath":"/job/Penang-Malaysia/Software-Engineer_R48236","locationsText":"Penang, Malaysia","postedOn":"Posted Today","bulletFields":["R48236","Penang, Malaysia (ZMY33)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":290},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":92},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":84},{"descriptor":"Manufacturing & Supply Chain","id":"5a650a685cb64a0ba694baa053e24bda","count":36},{"descriptor":"Information Technology","id":"c3fc17b768e842e39b7192f0bf4cb0f1","count":29},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":28},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":20},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":18},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":13},{"descriptor":"Administration & Facilities","id":"0191c22da3ac417c94d450ccdb06a7ed","count":6},{"descriptor":"Legal & Regulatory","id":"4170777a1c914320ad8828c0ec033c53","count":3},{"descriptor":"Human Resources","id":"8e651d1131bc4aad9a089b555adc3975","count":3}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"North America","id":"436f05d7afa343d5a8c9f92ef3e8c71b","count":195},{"descriptor":"Asia Pacific","id":"14bb6aa2c25e4a218b2a3faaa951e44c","count":131},{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":117},{"descriptor":"Latin America","id":"d6565dafd0ce4473932b0ce1ce9a0307","count":24}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":613},{"descriptor":"Part time","id":"43259991a4cc42f1a7570dd5dc911e13","count":9}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":5},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":21},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":23},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":61},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1},{"descriptor":"Korea, Republic of","id":"7a5a2aadf9d34086a2bfbfd408bc28da","count":1},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":58},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":6},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":1},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":94},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":10},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":34},{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":236},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"Alabama, US Offsite","id":"bbb70e9710004203b5c0165259b19722","count":1},{"descriptor":"Alabama Remote Work","id":"a2aa2501ee340139269db5448422f90a","count":1},{"descriptor":"Alberta Remote Work","id":"a2aa2501ee3401ebad8800458422350b","count":2},{"descriptor":"Albuquerque, NM (NM06)","id":"726d9bb69ca00184bc0a4eeaae18a9a7","count":2},{"descriptor":"Allen, TX (TX139)","id":"a2aa2501ee340194a7e124312b23666e","count":22},{"descriptor":"Antofagasta, Chile","id":"ff21797042291056c2292e32bd504b2e","count":1},{"descriptor":"Argentina Offsite (ZAR99)","id":"5b4156247dd945009ecdd0815cc32261","count":2},{"descriptor":"Arizona, US Offsite","id":"1427da907f71482e93d2ca9a94f4a721","count":20},{"descriptor":"Arizona Remote Work","id":"a2aa2501ee3401172758a8448422ef0a","count":14},{"descriptor":"Arkansas Remote Work","id":"a2aa2501ee340168512097448422e00a","count":2},{"descriptor":"Atlanta, GA","id":"e6754dd8376744ae8810143cfdbd586b","count":1},{"descriptor":"Austria Offsite (ZAT99)","id":"22cd4ef36d4410e861598876a5d8cdbe","count":2},{"descriptor":"Bangalore, India","id":"dc87e0de602f103e7f08db009e1c78c9","count":50},{"descriptor":"Bangalore, India (ZIN114)","id":"4114a9c5ddc5010679785ea9e8011a38","count":5},{"descriptor":"Bangalore offsite, India","id":"83e4449f1df80133688024551401456f","count":4},{"descriptor":"Bay Shore, NY (NY54)","id":"d879770ce580100165639203abdb0000","count":6},{"descriptor":"Beltsville, MD","id":"ec2584050ebf102fb4ed7d77e3a0219e","count":5},{"descriptor":"Berlin, Germany (ZWG172)","id":"da1bb7b30412011d12861db1754a47e2","count":4},{"descriptor":"Birmingham, AL","id":"37cbf3aa4d9810d6aa793a34d460121d","count":1},{"descriptor":"Bogota, Colombia (ZCL04)","id":"4e4bade28097445dbdf1e9acd5883db8","count":2},{"descriptor":"Brazil Offsite","id":"31e50f098c28482282d16915b1f03b02","count":1},{"descriptor":"Brazil Remote Work","id":"a2aa2501ee3401046547064584223a0b","count":15},{"descriptor":"British Columbia,CAN Offsite","id":"99abf5d326b8405d913f070afd962314","count":2},{"descriptor":"British Columbia Remote Work","id":"a2aa2501ee3401529baefa448422300b","count":2},{"descriptor":"Buenos Aires, Ar - bus cntr (ZAR20)","id":"82f5b0bf5d18014fe0aa2c9b8f01e376","count":2},{"descriptor":"Bulgaria Offsite (ZBU99)","id":"b20e212a792d4ebba04149117d379262","count":3},{"descriptor":"Cairo, Egypt","id":"27419f4f50f31074bf6d12933928093d","count":1},{"descriptor":"Calama, Chile","id":"5add0ac80d6801f6eb698aeb780d6d24","count":3},{"descriptor":"California Northern, US Offsite","id":"51094660fa0a4ec4b328886f73a854d2","count":5},{"descriptor":"California Northern Remote Work","id":"a2aa2501ee34015666cf5f448422b30a","count":12},{"descriptor":"California Southern, US Offsite","id":"2e27a5a31dfb43d6b1fe21b8f268733c","count":6},{"descriptor":"California Southern Remote Work","id":"a2aa2501ee34016f686b59448422ae0a","count":13},{"descriptor":"Charlotte, NC","id":"09f65edec644100fb96d7a9a30a7de0e","count":1},{"descriptor":"Chicago, IL","id":"56b899ac82d3102ebb10086c343f0eed","count":45},{"descriptor":"Chile Remote Work","id":"a2aa2501ee340133264bcf4484220d0b","count":1},{"descriptor":"Colorado, US Offsite","id":"14ab7340d6e645c1827628a28827563a","count":1},{"descriptor":"Colorado Remote Work","id":"a2aa2501ee34015a1230464484229f0a","count":8},{"descriptor":"Connecticut, US Offsite","id":"399e74c7d2c4436ea401e45369f54a9c","count":3},{"descriptor":"Connecticut Remote Work","id":"a2aa2501ee3401d887c339448422950a","count":2},{"descriptor":"Cork, Ireland","id":"61b9ddf3a0c51000b136358fdbcb0000","count":1},{"descriptor":"Cork, Ireland - Business CNTR (ZEI16)","id":"e8aed7fb96be1000b4bd44c6150c0000","count":29},{"descriptor":"Culver City, CA","id":"f2cb61a1d06a01e3044baadd1f01ba77","count":7},{"descriptor":"Dallas, TX","id":"d0be8406d7eb0108618092b78c8c3d7d","count":4},{"descriptor":"Dallas, TX (TX143)","id":"61b9ddf3a0c51000b1184fb114ed0000","count":1},{"descriptor":"Delaware, US Offsite","id":"fdbba75aa4044c649cf4ddd888004e1e","count":8},{"descriptor":"Delaware Remote Work","id":"a2aa2501ee3401860b4433448422900a","count":5},{"descriptor":"Dubai, UAE","id":"7dda71e222860100aa71137f4c680000","count":2},{"descriptor":"Eagan, MN","id":"45632196659f01ded4d69952ac36dd7a","count":1},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Elgin, IL","id":"56b899ac82d3102ebe1e9ed8fc6722d7","count":1},{"descriptor":"Farmington Hills, MI (MI17)","id":"da1bb7b3041201d56bf55c9f774a95e3","count":1},{"descriptor":"Florida, US Offsite","id":"024e19ecdef743ea8576fd1f592a479c","count":23},{"descriptor":"Florida Remote Work","id":"a2aa2501ee34015d6ddb26478422fd0c","count":25},{"descriptor":"Fornebu, Norway (ZNO11)","id":"ba927ad987ee01020389e6b494000000","count":1},{"descriptor":"Fort Collins, CO (CO29)","id":"4114a9c5ddc501787dea77fde7019936","count":2},{"descriptor":"Fort Worth, TX (TX135)","id":"731a6d25b4bc01260a2ef4efbe0b4e60","count":2},{"descriptor":"Framingham, MA","id":"442a24924422100157ed1e5a4c5c0000","count":2},{"descriptor":"Fresno, CA (CA180)","id":"4114a9c5ddc501232fd3ac42e7010636","count":2},{"descriptor":"Ft. Lauderdale, FL (FL87)","id":"da5e91a4328101abe15bda8ec823a9bc","count":3},{"descriptor":"Georgia, US Offsite","id":"f1180d181cc140dba59dd0e993a002f1","count":15},{"descriptor":"Georgia Remote Work","id":"a2aa2501ee3401b67a9904478422df0c","count":15},{"descriptor":"Germany Offsite (ZWG99)","id":"5c1aee55369b44a2a5136da8dec8e315","count":6},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Glostrup, Denmark (ZDK02)","id":"27a1c404f5744ae68442996960fe2804","count":3},{"descriptor":"Greater Chicago Area","id":"a2aa2501ee34015128ebf2468422d00c","count":15},{"descriptor":"Greater Dallas Area","id":"a2aa2501ee34013ba7b67b4584229a0b","count":1},{"descriptor":"Gurgaon, India","id":"d879770ce5801001ba2441f0f8260000","count":4},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1},{"descriptor":"Ho Chi Minh, Vietnam","id":"04fbb808deef1000aba4980e9ce60000","count":2},{"descriptor":"Ho Chi Minh City, Vietnam (ZVI16)","id":"da5e91a4328101b8bd368cee2324adf1","count":1},{"descriptor":"Idaho, US Offsite","id":"de8af0de8a4f43e49ea4d4dc5a432216","count":1},{"descriptor":"Idaho Remote Work","id":"a2aa2501ee3401e0c730f9468422d50c","count":2},{"descriptor":"Idstein, Germany (ZWG86)","id":"04a42199937044bbbf6010ed72d1d007","count":2},{"descriptor":"Illinois, US Offsite","id":"037ebcbfd6ee4ad8a96ca2f9ec955366","count":36},{"descriptor":"Illinois Remote Work","id":"a2aa2501ee3401b4149aec468422cb0c","count":29},{"descriptor":"Indiana, US Offsite","id":"86ac456645c1476581ccafcdabd07091","count":11},{"descriptor":"Indianapolis, IN","id":"7f977422e7ba456a98281fb6d502202e","count":1},{"descriptor":"Indiana Remote Work","id":"a2aa2501ee3401181c56e6468422c60c","count":18},{"descriptor":"India Offsite (ZIN99)","id":"801ee26ff10b4e2389d3a9d125e02ae3","count":2},{"descriptor":"Iowa, US Offsite","id":"1787eed6fea6446f9bc1036e9a5962d9","count":2},{"descriptor":"Iowa Remote Work","id":"a2aa2501ee34012b9d0fda468422bc0c","count":7},{"descriptor":"Italy Offsite (ZIT99)","id":"7de50b13083047dfb5400de1b3b32aba","count":1},{"descriptor":"Kansas, US Offsite","id":"061f9780eeaf4ab392eb38562e8635c0","count":4},{"descriptor":"Kansas Remote Work","id":"a2aa2501ee3401a115bcd4468422b70c","count":5},{"descriptor":"Kentucky, US Offsite","id":"5e9d2bcbc1df436db79c28a492f83838","count":2},{"descriptor":"Kentucky Remote Work","id":"a2aa2501ee340110c46bcf468422b20c","count":2},{"descriptor":"Krakow, Poland","id":"cdb6c301cead01c0fd6255fbbe0073b9","count":89},{"descriptor":"Krakow, Poland","id":"30c4e7f824bd4b1a892b4ee4a537c2f7","count":2},{"descriptor":"Krakow, Poland","id":"3cc51f087f9747d5b0b2af9d001b0281","count":1},{"descriptor":"Kuala Lumpur, Malaysia","id":"817fef2f26ad4eec85f3d1f59f67a08c","count":2},{"descriptor":"Lexington, SC (SC07)","id":"da5e91a43281017cec012a9ab8239ba2","count":1},{"descriptor":"Linthicum, MD","id":"c152d08a5f9c104eed32617c8087529c","count":3},{"descriptor":"Lisbon, Portugal","id":"d0be8406d7eb01df5699f9468d8cf97d","count":9},{"descriptor":"Lisbon, Portugal","id":"60d771b675b201dd1b8cf4a90e01c534","count":1},{"descriptor":"Little Rock, AR","id":"9294dc0527c54192b5c8338f762402d1","count":1},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":3},{"descriptor":"Los Angeles, CA","id":"75eeec0cd30c4823b7cdbc46c87436e3","count":1},{"descriptor":"Los Angeles, CA","id":"20b991fa96e9475db727dbe3c7df1156","count":1},{"descriptor":"Louisiana Remote Work","id":"a2aa2501ee340134851ac4468422a80c","count":1},{"descriptor":"Machias, NY","id":"0a19dc5a4f9f4112af112d95245b34fc","count":1},{"descriptor":"Madrid, Spain","id":"8cfc0951b3b94bd98139c963eb68ec99","count":2},{"descriptor":"Maine, US Offsite","id":"992c04fd1a9c41d3a6a904ffe0de680c","count":3},{"descriptor":"Maine Remote Work","id":"a2aa2501ee34019d8ee2b74684229e0c","count":5},{"descriptor":"Manitoba Remote Work","id":"a2aa2501ee3401b8f6e9f44484222b0b","count":3},{"descriptor":"Maryland, US Offsite","id":"b83767d4324c46c999f575fd542abd88","count":16},{"descriptor":"Maryland Remote Work","id":"a2aa2501ee3401dbf94bb2468422990c","count":18},{"descriptor":"Massachusetts, US Offsite","id":"ef9ff0866473431aa0807077edea046d","count":18},{"descriptor":"Massachusetts Remote Work","id":"a2aa2501ee340136dff99f4684228a0c","count":13},{"descriptor":"Melbourne, Australia","id":"d7e3ba3b107b442382576d564fcbadfd","count":2},{"descriptor":"Mexico City, Mexico","id":"2b254088ddb54694997bd94b011e140c","count":4},{"descriptor":"Mexico Offsite","id":"5ef0f2a16491016a2dbdefc5034f5d9c","count":1},{"descriptor":"Michigan, US Offsite","id":"4b3514833681469ba0b512c446b25b97","count":11},{"descriptor":"Michigan Remote Work","id":"a2aa2501ee3401621d8898468422830c","count":13},{"descriptor":"Minnesota, US Offsite","id":"efb7395e01e54bde949ac224af8f56a6","count":3},{"descriptor":"Minnesota Remote Work","id":"a2aa2501ee34018daff981468422740c","count":9},{"descriptor":"Mississippi Remote Work","id":"a2aa2501ee340143de0a7c4684226f0c","count":2},{"descriptor":"Missouri, US Offsite","id":"fb75ff372ac14e1b809a1dd53333021e","count":2},{"descriptor":"Missouri Remote Work","id":"a2aa2501ee340123e99d6f468422650c","count":5},{"descriptor":"Montana, US Offsite","id":"add06bd26cdc4dcca751f6506e808c6a","count":1},{"descriptor":"Montana Remote Work","id":"a2aa2501ee3401c92dfa69468422600c","count":1},{"descriptor":"Morocco Offsite (ZMO99)","id":"13183554e71d4ea3b51cc01fb4310a38","count":1},{"descriptor":"Muscat, Oman","id":"7af2294c87014d38b73cc1f8e8046db2","count":1},{"descriptor":"Nebraska Remote Work","id":"a2aa2501ee3401c3ed27644684225b0c","count":1},{"descriptor":"Nevada, US Offsite","id":"63ba34e24ce44a5d92912e0cadae491c","count":1},{"descriptor":"Nevada Remote Work","id":"a2aa2501ee34015e595a5e468422560c","count":2},{"descriptor":"New Hampshire, US Offsite","id":"0727cec59d1544888ff072b50e96a1c3","count":5},{"descriptor":"New Hampshire Remote Work","id":"a2aa2501ee3401e10a2558468422510c","count":3},{"descriptor":"Newington, VA","id":"a2d68824ae0f4fdfa99ac487376a60c0","count":1},{"descriptor":"New Jersey, US Offsite","id":"dd456a04291641a5b02b5731f3e70d4a","count":10},{"descriptor":"New Jersey Remote Work","id":"a2aa2501ee340154abd2524684224c0c","count":14},{"descriptor":"New Mexico, US Offsite","id":"0bf30a8368014b0e90cd36a3c4d20e1a","count":2},{"descriptor":"New Mexico Remote Work","id":"a2aa2501ee3401cff79a46468422420c","count":4},{"descriptor":"New York, US Offsite","id":"3f76dd361d8b410784ca4fc8dc2421f7","count":8},{"descriptor":"New York Remote Work","id":"a2aa2501ee34015fb0b438468422380c","count":11},{"descriptor":"North Carolina, US Offsite","id":"2080bb98030b4515ba37427d91ff32cc","count":13},{"descriptor":"North Carolina Remote Work","id":"a2aa2501ee34015223b220468422210c","count":17},{"descriptor":"North Dakota, US Offsite","id":"a9996a2fd97f4d3e95a330c9526ec0b3","count":1},{"descriptor":"North Dakota Remote Work","id":"a2aa2501ee3401842df90e468422120c","count":3},{"descriptor":"NY52","id":"20a50c646bd31001a94e433910780000","count":1},{"descriptor":"Offsite France (ZFR99)","id":"71f31ba331b642f3a3ae05b211a469d1","count":1},{"descriptor":"Ohio, US Offsite","id":"c9f53b4342e94035b77570cfe5599af6","count":15},{"descriptor":"Ohio Remote Work","id":"a2aa2501ee34011ff5ccfc458422030c","count":14},{"descriptor":"Oklahoma, US Offsite","id":"7ceb761aa15d46d7b6c9a6bb4d05c509","count":4},{"descriptor":"Oklahoma Remote Work","id":"a2aa2501ee3401d33bbaf6458422fe0b","count":4},{"descriptor":"ONT39","id":"5c4e189f92a610016f2ffc6e5c630000","count":1},{"descriptor":"Ontario Remote Work","id":"a2aa2501ee340179e5f7e8448422210b","count":10},{"descriptor":"Oregon, US Offsite","id":"746c5cc1f07d48d7837f3db4895a18e7","count":10},{"descriptor":"Oregon Remote Work","id":"a2aa2501ee3401d4d45ff0458422f90b","count":6},{"descriptor":"Orlando, FL","id":"b7c95ddf5a041015a61c88e160676351","count":2},{"descriptor":"Oslo, Norway (ZNO07)","id":"8ef71253a56d4aaf92ff5a5364ccc8ac","count":1},{"descriptor":"Ottawa, Canada","id":"77e555f21e5501db407373e92a70fa79","count":1},{"descriptor":"Parma, OH","id":"9efafca5ae9041f7980582836384f807","count":1},{"descriptor":"Penang, Malaysia","id":"c6d7e2b64f8b107f215186f1d658a224","count":56},{"descriptor":"Penang, Malaysia","id":"8dfc527f8ed44cee87fe36c1afbaf264","count":1},{"descriptor":"Penang, Malaysia","id":"168b0d8a3214463583f95156388faf2d","count":1},{"descriptor":"Pennsylvania, US Offsite","id":"89941ac3741f436ab4e333e49a8fba84","count":16},{"descriptor":"Pennsylvania Remote Work","id":"a2aa2501ee3401fe0c4ed8458422e50b","count":12},{"descriptor":"Phoenix, AZ","id":"d0be8406d7eb01fa50265759958cbf87","count":1},{"descriptor":"Plantation, FL","id":"17ba885223814f9ab57dedd1e725b00a","count":7},{"descriptor":"Plantation, FL","id":"d879770ce5801001b9b947c3860f0000","count":1},{"descriptor":"Poland Offsite (ZPL99)","id":"9587715495c14b2b946ee753f5adba22","count":8},{"descriptor":"Portugal Offsite (ZPT99)","id":"22e48e01af704af5acf68a768e1184ed","count":1},{"descriptor":"Puerto Rico Offsite","id":"c35e2c7bf9b1444bb4c00699df114d76","count":1},{"descriptor":"Quebec Remote Work","id":"a2aa2501ee34017ab529dc448422170b","count":6},{"descriptor":"Reynosa, Mexico","id":"2cc4589d2ab01001021366bdbd430000","count":2},{"descriptor":"Rhode Island, US Offsite","id":"75ccaab07ff843b4bb5433ed70cbaff7","count":4},{"descriptor":"Rhode Island Remote Work","id":"a2aa2501ee34018f99a6c6458422d60b","count":1},{"descriptor":"Richardson, TX (TX141)","id":"a1b4b9c5b61b016ad44e1b6108028e25","count":1},{"descriptor":"Richmond, VA","id":"9ea53914b84d01586593035807010e1b","count":1},{"descriptor":"Riyadh, Saudi Arabia","id":"dfff2595c3404fe89fcea0c4a139065c","count":2},{"descriptor":"Romania Offsite (ZRO99)","id":"88268c4ae43b48c1bd5baa7007a31a71","count":1},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Sacramento, CA","id":"c4ee93d3538249b29c9fb0bfde3295be","count":1},{"descriptor":"San Mateo, CA","id":"3955e91ab9be1000d6a5f34dfd560000","count":1},{"descriptor":"Santiago, Chile","id":"ff21797042291056c1ed919d43474a6f","count":2},{"descriptor":"Santiago, Chile","id":"ff21797042291056c2a0d44e6f564d8b","count":1},{"descriptor":"Sao Paulo, Brazil","id":"d234454abe5110015dd3a0c5bb570000","count":5},{"descriptor":"Sarasota, FL","id":"279a8a3ddd4d018ef74c6ecba500157e","count":1},{"descriptor":"Saskatchewan Remote Work","id":"a2aa2501ee34019300f5d5448422120b","count":3},{"descriptor":"Schaumburg, IL","id":"5983637b827e4ed097966aa984c7cf6c","count":9},{"descriptor":"Schaumburg, IL","id":"f90bd5bcf3df4205a301db42c4557bdd","count":1},{"descriptor":"Schio, Italy","id":"a66ea95a586801014b0a39c8aa730000","count":1},{"descriptor":"Seoul, Korea","id":"8c4c7f5076070100bf635b3ff800ed4e","count":1},{"descriptor":"Singapore, Singapore","id":"914a4f61913c10357f56e7fd0de4f904","count":1},{"descriptor":"Singapore, Singapore (ZSG38)","id":"c6d7e2b64f8b107f233884cad328a5a5","count":1},{"descriptor":"Somerville, MA","id":"d0be8406d7eb01197d6786d18c8c617d","count":2},{"descriptor":"South Carolina, US Offsite","id":"4548f2167eca45daaa61d7c4aa7d08da","count":2},{"descriptor":"South Carolina Remote Work","id":"a2aa2501ee3401ac594eb9458422cc0b","count":10},{"descriptor":"South Dakota, US Offsite","id":"520ca850ee1443438ff88ea729c5dc1f","count":1},{"descriptor":"South Dakota Remote Work","id":"a2aa2501ee3401e9b731b3458422c70b","count":2},{"descriptor":"Spain Offsite (ZES99)","id":"301a357729b94516a34e3a61a35c1bb5","count":1},{"descriptor":"St. Petersburg, FL (FL92)","id":"4114a9c5ddc501b041023c10a301a7b6","count":1},{"descriptor":"Sterling, VA","id":"ca833823055501ee67c0d0e6ff01d6ee","count":1},{"descriptor":"St Petersburg, FL","id":"b9d0a434256f01442efa8db524cf8e23","count":1},{"descriptor":"Switzerland Offsite (ZSW99)","id":"bc6c8eecc49e4078ac65cd83165d02c5","count":1},{"descriptor":"Sydney, Australia (ZAS102)","id":"a161ce532f951001110b54a8d1f80000","count":1},{"descriptor":"Taguig, Philippines","id":"c6c7d41a752501ed42def116f4000e0e","count":1},{"descriptor":"Tennessee, US Offsite","id":"aa9f12002a984c16858ff0b2be54fce4","count":14},{"descriptor":"Tennessee Remote Work","id":"a2aa2501ee3401a15dcfac458422c20b","count":15},{"descriptor":"Texas, US Offsite","id":"7951f208c4a44af291de95d7063ca8ea","count":34},{"descriptor":"Texas Remote Work","id":"a2aa2501ee3401bb3ac08d458422a90b","count":26},{"descriptor":"Tokyo, Japan","id":"8c4c7f50760701262d4b1accf800fb4f","count":1},{"descriptor":"Toronto, Canada (ONT40)","id":"442a249244221001582c47e270eb0000","count":6},{"descriptor":"United Arab Emirates Offsite (ZUA99)","id":"dcc3bd6cdddc4454ad3336c2520953a5","count":1},{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":20},{"descriptor":"Utah, US Offsite","id":"f61b91f41da34642ae840d013eb6ec7d","count":19},{"descriptor":"Utah Remote Work","id":"a2aa2501ee3401463afc6e458422900b","count":11},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Vancouver, Canada","id":"d0be8406d7eb01e1ef6d1c418c8cf679","count":8},{"descriptor":"Vermont Remote Work","id":"a2aa2501ee3401d6729461458422840b","count":3},{"descriptor":"Versailles, France","id":"7dda71e222860100ab254c24897f0000","count":1},{"descriptor":"Vienna, Austria","id":"46a2113a7c421062bd06fb72dee26f45","count":1},{"descriptor":"Virginia, US Offsite","id":"c6987245ed6b4552b729aa8ca40c084f","count":16},{"descriptor":"Virginia Remote Work","id":"a2aa2501ee3401aefdf55a4584227f0b","count":11},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Warsaw, Poland","id":"d4e8b75046371067ca56ac231068e8e9","count":2},{"descriptor":"Warsaw, Poland","id":"c3422e7a11fd466e8a10d70edc3171ce","count":2},{"descriptor":"Washington, US Offsite","id":"0270f0ddaa9c4df780efe79b9477a4dc","count":5},{"descriptor":"Washington DC, US Offsite","id":"6703b0349e294f7982d1105b4180e6bf","count":4},{"descriptor":"Washington DC Remote Work","id":"a2aa2501ee34012ca4a4274484228b0a","count":6},{"descriptor":"Washington Remote Work","id":"a2aa2501ee3401c3bf02344584225d0b","count":10},{"descriptor":"Westminster, CO","id":"435c641825b8436a950f0c3c604cc62e","count":1},{"descriptor":"West Valley City, UT","id":"dc4b44bb9c9210367f2102c8f37b8c34","count":2},{"descriptor":"West Virginia, US Offsite","id":"41c94f5726b54db19a40ed8ab4c7016f","count":1},{"descriptor":"West Virginia Remote Work","id":"a2aa2501ee3401a5c1d62d458422580b","count":3},{"descriptor":"Wisconsin, US Offsite","id":"e350deb449e548d7be5c7185f399be05","count":3},{"descriptor":"Wisconsin Remote Work","id":"a2aa2501ee340159152027458422530b","count":14},{"descriptor":"Woodcliff Lake, NJ","id":"56b899ac82d3102ebddb9e5d99cf2205","count":2},{"descriptor":"Wyoming, US Offsite","id":"857b68215cb8413f8fc0085cc2df67b3","count":1},{"descriptor":"Wyoming Remote Work","id":"a2aa2501ee3401412f02214584224e0b","count":4},{"descriptor":"ZAS100","id":"20a50c646bd31001a8ec21fd6d5f0000","count":2}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:43 GMT
 - request:
     method: post
     uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/jobs
@@ -957,7 +369,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:43 GMT
+      - Tue, 30 Jul 2024 16:26:44 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -971,44 +383,44 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=b1400e38ee54fff08723d08e9187c1635fd495fd-instance=vps-prod-ka2d8tvk.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=f2a405104d951d61d089d118e7e0b73e14f4dfec-instance=vps-prod-071g796n.prod-vps.pr501.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=uh6xyNKwlVfBVfhlh66MHkFy7zgdBkhbp1Gps3ZFRTk-1722244483-1.0.1.1-jpHPJddyYZlqCsD5si86vbx3EPCBvbB4Xor0sJoZ8NM6DTmg_m7v_b0NadUeSvuG2zhUm2v4b4ln9UjbHGeDLA;
-        path=/; expires=Mon, 29-Jul-24 09:44:43 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=pTQ4rP5Q4U1UpvIe.AcgCaqSbs_8JrcvX.a0yCHSGKg-1722356804-1.0.1.1-_nXOHkOs830utmgU05YqmapNOQN9oNhIsE_XpNsKE5Pey2u12KAf3lyBjqx97FUtkEJCVDIuhjeKfystQ8ACEA;
+        path=/; expires=Tue, 30-Jul-24 16:56:44 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLeTYyWYf7NxYcM2PJN6MQRcRnTW; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:43 GMT; HttpOnly
-      - _cfuvid=a.VI_1QCUhwEEdHKUrW_bRz2YMwQQlzMROKfcHrUXDU-1722244483638-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLeTYyWYf7NxYcM1ZzvQsVUD3nMz; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:44 GMT; HttpOnly
+      - _cfuvid=siIlfO3vVKlY55wYYkxHSDCHR7S62kOgX5vhHnR_NI4-1722356804197-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=a9c8409c-aeff-450e-9efb-f22542bdb69a; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=1877646346.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=a3d824c7-1fb6-4b15-ad3a-5687a18387d1; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=1072339978.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|2b0b359c-8f1f-402d-b76c-2461906d61be
+      - VPS|8c4eba46-d5c7-487d-9336-7a25aec623eb
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - DYNAMIC
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=odE7G41nYTMnoPWLYNehqmtGFmv%2BeRPPpSH%2FKnJpZQ0hrLddttgrhqCpCPCrj0TVmKrxVLWjKjhrSjKlkGufO66ls8TS%2Bvq1s0orI2cftvEJKx4pU7jdgm7v83sPQkk8D9u2GF8UscY%2FLUdrFMgkvdHK%2FMOp4q5zlA%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=qXt7JK4Xw7%2BcAEfg8%2F7u%2BuhofuZiGjLUmdP0QGM2BfFPSaPfJppLi3%2FL69k%2BK%2B5Er4C%2F07R2y6h%2BV3dMgluBnMX8kL3VD5SIS%2Bi1xo8mXgEV54IXAHACM%2BnuwtP1Rg7LuhKKJZJxhM%2FJtBBV9wKqxV1dBp%2BDC5SBkQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac0013a8791835-EWR
+      - 8ab6b6467f604231-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"total":35,"jobPostings":[{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48791","Rugby, UK (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Today","bulletFields":["R48793","Rugby, UK (ZUK107)"]},{"title":"Senior Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Software-Engineer_R48898-1","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 3 Days Ago","bulletFields":["R48898","Edinburgh, UK (ZUK129)"]},{"title":"Digital Campaigns Manager - EMEA","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Digital-Campaigns-Manager---EMEA_R45720","locationsText":"United Kingdom Offsite (ZUK99), More...","postedOn":"Posted 4 Days Ago","bulletFields":["R45720","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - North England & Midlands","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---Midlands_R48681","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 4 Days Ago","bulletFields":["R48681","United Kingdom Offsite (ZUK99)"]},{"title":"Technical Project Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Technical-Project-Manager_R47762","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 4 Days Ago","bulletFields":["R47762","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---South_R48682","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 5 Days Ago","bulletFields":["R48682","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Transmission Design Engineer / Authority","externalPath":"/job/Rugby-UK-ZUK107/Senior-Transmission-Design-Engineer---Authority_R48609","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 5 Days Ago","bulletFields":["R48609","Rugby, UK (ZUK107)"]},{"title":"Senior FP&A Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Senior-FP-A-Manager_R48163","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 6 Days Ago","bulletFields":["R48163","United Kingdom Offsite (ZUK99)"]},{"title":"Account Director – South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Account-Director---South_R48669","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 11 Days Ago","bulletFields":["R48669","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Frontend Developer","externalPath":"/job/Uxbridge-UK-ZUK131/Senior-Frontend-Developer_R48511","locationsText":"Uxbridge, UK (ZUK131), More...","postedOn":"Posted 13 Days Ago","bulletFields":["R48511","Uxbridge, UK (ZUK131)"]},{"title":"Regional Sales Director, CAM UK & Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Regional-Sales-Director--CAM-UK---Ireland_R48590","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 13 Days Ago","bulletFields":["R48590","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Sales Executive - South East","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---South-East_R48471","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 13 Days Ago","bulletFields":["R48471","United Kingdom Offsite (ZUK99)"]},{"title":"Senior System Engineer","externalPath":"/job/Rugby-UK-ZUK107/Senior-System-Engineer_R48513","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 14 Days Ago","bulletFields":["R48513","Rugby, UK (ZUK107)"]},{"title":"Channel Marketing Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Marketing-Manager_R47820-1","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 18 Days Ago","bulletFields":["R47820","United Kingdom Offsite (ZUK99)"]},{"title":"Software Configuration and Integrations Engineer","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Software-Configuration-and-Integrations-Engineer_R48514","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 18 Days Ago","bulletFields":["R48514","United Kingdom Offsite (ZUK99)"]},{"title":"Sr. Manager U.K. and Ireland Communications","externalPath":"/job/London-UK/Sr-Manager-UK-and-Ireland-Communications_R48263-1","locationsText":"London, UK","postedOn":"Posted 27 Days Ago","bulletFields":["R48263","London, UK (ZUK120)"]},{"title":"Junior Software Engineer","externalPath":"/job/Glasgow-UK-ZUK118/Junior-Software-Engineer_R47941","locationsText":"Glasgow, UK (ZUK118)","postedOn":"Posted 27 Days Ago","bulletFields":["R47941","Glasgow, UK (ZUK118)"]},{"title":"Senior Embedded Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Embedded-Software-Engineer_R47952","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 30+ Days Ago","bulletFields":["R47952","Edinburgh, UK (ZUK129)"]},{"title":"Channel Sales Executive - Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---Ireland_R48205","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48205","United Kingdom Offsite (ZUK99)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":16},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":6},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":4},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":3},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":3},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":2},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":1}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":35}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":35}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":227},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":96},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":64},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":60},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":35},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":24},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":19},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":9},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":8},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":5},{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":2},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":2},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"Taiwan","id":"a4e08b475d6a4176853c9d1cb9854e02","count":1},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":21},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":4},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
-  recorded_at: Mon, 29 Jul 2024 09:14:43 GMT
+        {"total":34,"jobPostings":[{"title":"Technical Support Specialist","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted Yesterday","bulletFields":["R48704","United Kingdom Offsite (ZUK99)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Yesterday","bulletFields":["R48791","Rugby, UK (ZUK107)"]},{"title":"Customer Service & IT Advisor","externalPath":"/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48793","locationsText":"Rugby, UK (ZUK107)","postedOn":"Posted Yesterday","bulletFields":["R48793","Rugby, UK (ZUK107)"]},{"title":"Senior Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Software-Engineer_R48898-1","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 4 Days Ago","bulletFields":["R48898","Edinburgh, UK (ZUK129)"]},{"title":"Channel Account Manager - North England & Midlands","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---Midlands_R48681","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 5 Days Ago","bulletFields":["R48681","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Account Manager - South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Account-Manager---South_R48682","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 6 Days Ago","bulletFields":["R48682","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Transmission Design Engineer / Authority","externalPath":"/job/Rugby-UK-ZUK107/Senior-Transmission-Design-Engineer---Authority_R48609","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 6 Days Ago","bulletFields":["R48609","Rugby, UK (ZUK107)"]},{"title":"Senior FP&A Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Senior-FP-A-Manager_R48163","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 7 Days Ago","bulletFields":["R48163","United Kingdom Offsite (ZUK99)"]},{"title":"Account Director – South","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Account-Director---South_R48669","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 12 Days Ago","bulletFields":["R48669","United Kingdom Offsite (ZUK99)"]},{"title":"Senior Frontend Developer","externalPath":"/job/Uxbridge-UK-ZUK131/Senior-Frontend-Developer_R48511","locationsText":"Uxbridge, UK (ZUK131), More...","postedOn":"Posted 14 Days Ago","bulletFields":["R48511","Uxbridge, UK (ZUK131)"]},{"title":"Regional Sales Director, CAM UK & Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Regional-Sales-Director--CAM-UK---Ireland_R48590","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 14 Days Ago","bulletFields":["R48590","United Kingdom Offsite (ZUK99)"]},{"title":"Channel Sales Executive - South East","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---South-East_R48471","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 14 Days Ago","bulletFields":["R48471","United Kingdom Offsite (ZUK99)"]},{"title":"Senior System Engineer","externalPath":"/job/Rugby-UK-ZUK107/Senior-System-Engineer_R48513","locationsText":"Rugby, UK (ZUK107), More...","postedOn":"Posted 15 Days Ago","bulletFields":["R48513","Rugby, UK (ZUK107)"]},{"title":"Channel Marketing Manager","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Marketing-Manager_R47820-1","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 19 Days Ago","bulletFields":["R47820","United Kingdom Offsite (ZUK99)"]},{"title":"Software Configuration and Integrations Engineer","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Software-Configuration-and-Integrations-Engineer_R48514","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 19 Days Ago","bulletFields":["R48514","United Kingdom Offsite (ZUK99)"]},{"title":"Sr. Manager U.K. and Ireland Communications","externalPath":"/job/London-UK/Sr-Manager-UK-and-Ireland-Communications_R48263-1","locationsText":"London, UK","postedOn":"Posted 28 Days Ago","bulletFields":["R48263","London, UK (ZUK120)"]},{"title":"Junior Software Engineer","externalPath":"/job/Glasgow-UK-ZUK118/Junior-Software-Engineer_R47941","locationsText":"Glasgow, UK (ZUK118)","postedOn":"Posted 28 Days Ago","bulletFields":["R47941","Glasgow, UK (ZUK118)"]},{"title":"Senior Embedded Software Engineer","externalPath":"/job/Edinburgh-UK-ZUK129/Senior-Embedded-Software-Engineer_R47952","locationsText":"Edinburgh, UK (ZUK129)","postedOn":"Posted 30+ Days Ago","bulletFields":["R47952","Edinburgh, UK (ZUK129)"]},{"title":"Channel Sales Executive - Ireland","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Channel-Sales-Executive---Ireland_R48205","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48205","United Kingdom Offsite (ZUK99)"]},{"title":"Finance Business Partner","externalPath":"/job/United-Kingdom-Offsite-ZUK99/Finance-Business-Partner_R48124","locationsText":"United Kingdom Offsite (ZUK99)","postedOn":"Posted 30+ Days Ago","bulletFields":["R48124","United Kingdom Offsite (ZUK99)"]}],"facets":[{"facetParameter":"jobFamilyGroup","descriptor":"Job Category","values":[{"descriptor":"Engineering & Sciences","id":"2161bef685534428b91fad96fc9069b4","count":15},{"descriptor":"Sales","id":"51170c2b83944d19b9666b23fc81a3b4","count":6},{"descriptor":"Service & Support","id":"c2197eea2758408bbbe52d2c04006230","count":5},{"descriptor":"Finance","id":"8e0e5fd2f9d246ce9c29c005c2dd4868","count":3},{"descriptor":"General Management & Operations","id":"659a52e90f764b73bcb230a3ab5bb6d5","count":2},{"descriptor":"Marketing","id":"98e69dcc548d4f27b918cd1a989abb24","count":2},{"descriptor":"Professional Services","id":"60d771b675b201093e19718f600171af","count":1}]},{"facetParameter":"timeType","descriptor":"Regions","values":[{"descriptor":"Europe Middle East Africa","id":"e61d35cf9e484fa080984bec674f16ca","count":34}]},{"facetParameter":"timeType123","descriptor":"Time Type","values":[{"descriptor":"Full time","id":"6e8e99fd0c7648ebbf0074d32dc873f5","count":34}]},{"facetParameter":"locationMainGroup","values":[{"facetParameter":"locationCountry","descriptor":"Countries","values":[{"descriptor":"United States of America","id":"bc33aa3152ec42d4995f4791a106ed09","count":236},{"descriptor":"Poland","id":"131d5ac7e3ee4d7b962bdc96e498e412","count":94},{"descriptor":"India","id":"c4f78be1a8f14da0ab49ce1162348a5e","count":61},{"descriptor":"Malaysia","id":"972dc4ba8d454bc0b893ff84b1529077","count":58},{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","count":34},{"descriptor":"Ireland","id":"04a05835925f45b3a59406a2a6b72c8a","count":30},{"descriptor":"Canada","id":"a30a87ed25634629aa6c3958aa2b91ea","count":23},{"descriptor":"Brazil","id":"1a29bb1357b240ab99a2fa755cc87c0e","count":21},{"descriptor":"Germany","id":"dcc5b7608d8644b3a93716604e78e995","count":10},{"descriptor":"Portugal","id":"2e8c5034deb045d49315417c347472ca","count":10},{"descriptor":"Chile","id":"53fe09ef12b9408682a1d2439823f2e0","count":8},{"descriptor":"Mexico","id":"e2adff9272454660ac4fdb56fc70bb51","count":6},{"descriptor":"Australia","id":"d903bb3fedad45039383f6de334ad4db","count":5},{"descriptor":"Argentina","id":"e42ad5eac46d4cc9b367ceaef42577c5","count":4},{"descriptor":"Bulgaria","id":"25f4875dc598484dbeee857eb2d81652","count":3},{"descriptor":"Austria","id":"d004c0d1a6c84511ab048669fcdf9fd7","count":3},{"descriptor":"United Arab Emirates","id":"7b4fa1f369bd4604ba3692682fcbe345","count":3},{"descriptor":"Denmark","id":"49ab063f422741e2aef271de00efeac8","count":3},{"descriptor":"Spain","id":"bd34c524a6a04ae6915f5d96fa086199","count":3},{"descriptor":"Vietnam","id":"db69e8c8446c11de98360015c5e6daf6","count":3},{"descriptor":"Norway","id":"d07f8ca8625e4345b98a91d0558b872a","count":2},{"descriptor":"Colombia","id":"e8106cd6a3534f2dba6fdee2d41db89d","count":2},{"descriptor":"France","id":"54c5b6971ffb4bf0b116fe7651ec789a","count":2},{"descriptor":"Saudi Arabia","id":"50423b5190ad49bb89e94cd58dfaad69","count":2},{"descriptor":"Singapore","id":"80938777cac5440fab50d729f9634969","count":2},{"descriptor":"Italy","id":"8cd04a563fd94da7b06857a79faaf815","count":2},{"descriptor":"Romania","id":"f2e609fe92974a55a05fc1cdc2852122","count":1},{"descriptor":"Switzerland","id":"187134fccb084a0ea9b4b95f23890dbe","count":1},{"descriptor":"Egypt","id":"d865e83093ad42319653b08e61f7db49","count":1},{"descriptor":"Philippines","id":"e56f1daf83e04bacae794ba5c5593560","count":1},{"descriptor":"Oman","id":"e8424552931249ba9c6c1d7706cdc01d","count":1},{"descriptor":"Morocco","id":"7aaca3f6fc774f16802a4df4718a5b53","count":1},{"descriptor":"Korea, Republic of","id":"7a5a2aadf9d34086a2bfbfd408bc28da","count":1},{"descriptor":"Japan","id":"8b705da2becf43cfaccc091da0988ab2","count":1}]},{"facetParameter":"locations","descriptor":"Locations","values":[{"descriptor":"United Kingdom Offsite (ZUK99)","id":"28a58b9f33bd4501bc45c1e0090787d1","count":20},{"descriptor":"Edinburgh, UK (ZUK129)","id":"8ea7f11f5aab01453121bf8100021cae","count":6},{"descriptor":"Rugby, UK (ZUK107)","id":"1d2d122d7b941052536edc0a7377754b","count":4},{"descriptor":"London, UK","id":"da4333eb67da105ec6b8a11cf8b7b278","count":3},{"descriptor":"Uxbridge, UK (ZUK131)","id":"ba927ad987ee01020316599466110000","count":3},{"descriptor":"Glasgow, UK (ZUK118)","id":"c58eb349976110517e3f4e27ea7ff036","count":2},{"descriptor":"Ware, UK","id":"d879770ce5801001659eb0e9b57b0000","count":2},{"descriptor":"Hemel Hempstead (ZUK113)","id":"1d2d122d7b9410525727fa7446ff9305","count":1}]}]},{"facetParameter":"distance","descriptor":"Distance","values":[{"descriptor":"10 miles","id":"a538cdb60a631000078a2c60ed1700f3","count":1},{"descriptor":"25 miles","id":"a538cdb60a631000078a2c6a410300f4","count":1},{"descriptor":"50 miles","id":"a538cdb60a631000078a2c6eadd300f5","count":1},{"descriptor":"100 miles","id":"a538cdb60a631000078a2c71efcc00f6","count":1},{"descriptor":"Any Distance","id":"a538cdb60a631000078a2c74f73b00f7","count":1}]}],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:44 GMT
 - request:
     method: get
-    uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791
+    uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704
     body:
       encoding: US-ASCII
       string: ''
@@ -1025,7 +437,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:44 GMT
+      - Tue, 30 Jul 2024 16:26:44 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -1039,41 +451,41 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=a4fc262bad555ffe4265e60e5bf2316f0c4096c7-instance=vps-prod-nfrhuzjx.prod-vps.pr502.cust.pdx.wd;
+      - PLAY_SESSION=610fd078649b5b3135b4ca17abe032a963ff5f0f-instance=vps-prod-d3vqmhlz.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=rJZwmkByB102rwB7P1aXldXwRdB_SAgCKkXROxUsQTo-1722244484-1.0.1.1-A0MnuBrlbWUpPVh.AYqNulUyFsnV5Rflo06iBAb7qUpeYWr4J7w9o_6_Xnm_JhAhOwVd20VRDdNCx_L9zpp4AQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:44 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=HWbG_aHSXnIArVFqK5TM9srdIyJb.NtmrabKcaC31eE-1722356804-1.0.1.1-OMvjaOjF0t9kYCIcNyFV6gCFHNj1lARifUF4R9mymPqzDAFN0UsZ67DmpZ2hJdu2DMN0Yp3ZFRzVd8GopQeykQ;
+        path=/; expires=Tue, 30-Jul-24 16:56:44 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKLeTYyWYf7NxYcM2Q3BcYy5EhSwv; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:44 GMT; HttpOnly
-      - _cfuvid=owoEyf_EmBnwY_m.SIigGjLvPkVwbfz1C3XUNcDtsqo-1722244484594-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLf1exjNbMDM5uxf1uTfVxSybfit; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:44 GMT; HttpOnly
+      - _cfuvid=AGQWztR3fKgzavyVsOv9y1L8qU3lTbs.Eiw4XZY0QQs-1722356804856-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=31a4a389-c01d-4fab-9439-de6abcf24fc7; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=4243364874.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=934fdbbb-b9c1-4306-b43a-8a411db99867; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=2548866058.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|c78d93f5-94c4-4f76-bb10-296a4ef6102b
+      - VPS|e2c5341c-75e8-4ba5-b63e-0af726734342
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - BYPASS
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=%2F1uSlGpQSFwCnMHsLEJiJdDE%2BU3MAO%2Biop5%2F7u9raH1S71UFZxEdGapxj6wmivyWt8HHmXmHhyePfeIM2wonQEj7ud9r4nzz7HpvUeJ8mD%2BWW49HvzDVyEBXDnkAKeg8f2ibcrHmvQjoAnh4EUZqqqjoxvbPzKUlbQ%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=GwZXozNGwN3u2pFVWmyLH92FiGZI%2BxTPPjDjckey5K%2B1YzygfPR3dXznsstyIQ%2BukG%2BnNk0LOkPtFjU%2B1F8Rid5O0E25wByQVo3IDZUuww62pXE%2BxQa28lXgl85f%2FYF0b4VKBeJgo3SzZWjDu0NRB4L%2BCGML2BTDjA%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac001a88c5c32d-EWR
+      - 8ab6b64c6df8c32b-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"jobPostingInfo":{"id":"0534f03727521000a37ba343a8f50000","title":"Customer Service & IT Advisor","jobDescription":"<h2><b>Company Overview</b></h2><p style=\"text-align:left\"><span>At Motorola Solutions, we&#39;re guided by a shared purpose - helping people be their best in the moments that matter - and we live up to our purpose every day by solving for safer. Because people can only be their best when they not only feel safe, but are safe. We&#39;re solving for safer by building the best possible technologies across every part of our safety and security ecosystem. That&#39;s mission-critical communications devices and networks, AI-powered video security &amp; access control and the ability to unite voice, video and data in a single command center view. We&#39;re solving for safer by connecting public safety agencies and enterprises, enabling the collaboration that&#39;s critical to connect those in need with those who can help. The work we do here matters.</span></p><h2><br /><b>Department Overview</b></h2>To deliver excellent Customer Service to Motorola Customers through effective and professional handing of Customer Incidents, Service Requests, Queries, Complaints and Internal IT issues received via telephone, email or Service Management Terminal.<br><br>This is the Motorola first point of contact and is in place to deliver first class service through effective resolution of incidents, and to proactively build an ongoing relationship with the customer. The role holder will understand and respond to the customer needs professionally.<h2><br>Job Description</h2><p><b>This role is also based onsite out of our Rugby office 5 days a week.</b></p><p></p><p><b>This role will require SC and NPPV3 security clearance which includes living in the UK for at least the past 5 years.</b></p><p></p><p>The role holder will develop and grow the skills required to support future products and services offered by Motorola including data products This is achieved through:</p><p></p><p>Development, improvement and adherence to, industry leading processes, procedures and best practices. Consistent delivery against agreed OLAs/KPIs and operational targets and Service Levels.</p><p></p><p>The delivery of a high quality and effective service management standard within the respective support procedures and activities.</p><p></p><p>The actions taken by this role and responsibility to the wider organisation will directly influence the customer &amp; desire to continue to employ the Motorola Services. The actions taken in this role and responsibility to the wider organisation will directly reflect in the Pulse of the Customer scores and the perception of Motorola&#39;s ability to manage customer contractual obligations and maintain excellent service.</p><p></p><p>The role holder will strive to achieve the customer service standards and targets that are agreed and documented in our customer contracts and meet high standards of operational excellence and delivery of quality. If this role did not exist then there would be no first line contact and diagnostic support for our customers.</p><p></p><p><b>Key Tasks:</b></p><p>• Customer Ingress and liaison by Phone, Email and Service Management Systems.</p><p>• Triage Incidents and Requests at a 1st line level, resolving at 1st line where possible.</p><p>• Use BMC Remedy to record, assign, monitor and update cases.</p><p>• Liaise with Suppliers for timely updates and co-ordinate responses.</p><p>• Progress and track orders through their life cycle to delivery.</p><p>• Monitor the jeopardy status and progress of cases.</p><p>• Escalate failure and risk to service level achievement.</p><p>• Ensure quality and accuracy of case data, identifying &amp; supporting Continual Service Improvement.</p><p></p><p>The role requires strength in organisation, collaboration, communication, negotiation, service delivery, influencing and the ability to deal with difficult customers.</p><p></p><p>Ability to develop and maintain strong working relationships within and outside the service desk environment.</p><p></p><p>Have demonstrable service desk experience and be able to evidence the ability to operate successfully in a demanding environment, whilst maintaining high morale, high achievement and actively supporting the collaborative culture that drives success.</p><p></p><p>Proactive approach to removing barriers and finding solutions to problems.</p><p>Flexible approach to operational demands and situations due to the changing nature of the role.</p><h2><br>Basic Requirements</h2><p><b>Basic Requirements</b></p><p>• Analytical skills and disciplined approach to resolving complex issues</p><p>• Able to improve processes and procedures</p><p>• Communication skills: Verbal, Written, Listening, and Questioning.</p><p>• Personal organisational skills</p><p>• The ability to influence and negotiate with internal and external parties</p><p>• Customer Focus</p><p>• Able to deal with change</p><p>• Ability to embrace new technologies</p><p>• Self motivated and enthusiastic</p><p>• Problem solving and fact-finding skills</p><p></p><p><b>Core competencies</b></p><p>• Proven ability in communication, both written and verbal</p><p>• Experience of working in a call centre or service centre environment</p><p>• Proficient in Computer systems and packages.</p><p>• Experience of working self-sufficiently and in a team environment delivering customer service</p><p>• ITIL V4 Foundation Qualification would be desirable.</p><p></p><p><b>In return for your expertise, we’ll support you in this new challenge with coaching and development every step of the way. Also, to reward your hard work you’ll get:</b></p><ul><li>Competitive salary and bonus schemes.</li><li>Two weeks additional pay per year (holiday bonus).</li><li>25 days holiday entitlement &#43; bank holidays. </li><li>Attractive defined contribution pension scheme.</li><li>Employee stock purchase plan.</li><li>Life assurance.</li><li>Enhanced maternity and paternity pay.</li><li>Career development support and wide ranging learning opportunities.</li><li>Employee health and wellbeing support EAP, wellbeing guidance etc.</li><li>Carbon neutral initiatives/goals.</li><li>Corporate social responsibility initiatives including support for volunteering days.</li><li>Well known companies discount scheme.</li></ul><p>#LI-KTB</p><h2><br>Travel Requirements</h2>Under 10%<h2><br>Relocation Provided</h2>None<h2><br>Position Type</h2>Experienced<p style=\"text-align:inherit\"></p><h2>Referral Payment Plan</h2>Yes<p style=\"text-align:inherit\"></p><h2><b>Company</b></h2>Airwave Solutions Limited<p></p><p><i><b>EEO Statement</b></i></p><p></p><p><span>Motorola Solutions is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion or belief, sex, sexual orientation, gender identity, national origin, disability, veteran status or any other legally-protected characteristic. </span></p><p></p><p><span>We are proud of our people-first and community-focused culture, empowering every Motorolan to be their most authentic self and to do their best work to deliver on the promise of a safer world. If you’d like to join our team but feel that you don’t quite meet all of the preferred skills, we’d still love to hear why you think you’d be a great addition to our team.</span></p><p></p><p><span>We’re committed to providing an inclusive and accessible recruiting experience for candidates with disabilities, or other physical or mental health conditions. To request an accommodation, please email </span><a href=\"mailto:ohr&#64;motorolasolutions.com\" target=\"_blank\"><span>ohr&#64;motorolasolutions.com</span></a>.</p>","location":"Rugby, UK (ZUK107)","postedOn":"Posted Today","startDate":"2024-07-29","timeType":"Full time","jobReqId":"R48791","jobPostingId":"Customer-Service---IT-Advisor_R48791","jobPostingSiteId":"Careers","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7"},"canApply":true,"posted":true,"includeResumeParsing":true,"jobRequisitionLocation":{"descriptor":"Rugby, UK (ZUK107)","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","alpha2Code":"GB"}},"externalUrl":"https://motorolasolutions.wd5.myworkdayjobs.com/Careers/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","questionnaireId":"a5be17decf0a100143593b79a2310000","secondaryQuestionnaireId":"088e7c9c80bf1001f0d143420d020000"},"hiringOrganization":{"name":"908250 Airwave Solutions Limited","url":""},"similarJobs":[],"userAuthenticated":false}
-  recorded_at: Mon, 29 Jul 2024 09:14:44 GMT
+        {"jobPostingInfo":{"id":"0534f03727521000b18e611ec37e0000","title":"Technical Support Specialist","jobDescription":"<h2><b>Company Overview</b></h2><p style=\"text-align:left\"><span>At Motorola Solutions, we&#39;re guided by a shared purpose - helping people be their best in the moments that matter - and we live up to our purpose every day by solving for safer. Because people can only be their best when they not only feel safe, but are safe. We&#39;re solving for safer by building the best possible technologies across every part of our safety and security ecosystem. That&#39;s mission-critical communications devices and networks, AI-powered video security &amp; access control and the ability to unite voice, video and data in a single command center view. We&#39;re solving for safer by connecting public safety agencies and enterprises, enabling the collaboration that&#39;s critical to connect those in need with those who can help. The work we do here matters.</span></p><h2><br /><b>Department Overview</b></h2>Motorola Solutions is a global leader in mission-critical communications and analytics. Our technology platforms in mission-critical communications, command center software and video security &amp; analytics, make cities safer as well as help communities and businesses thrive. At Motorola Solutions, we are ushering in a new era in public safety and security. Motorola Solution’s Video Division is defining the future of the security industry through innovative end-to-end-solutions and award-winning AI based surveillance systems. Artificial Intelligence is transforming the world and our team is advancing the field as it applies to the surveillance industry. We are proud to be industry leaders in video analytics with products like Appearance Search and Unusual Motion Detection along with our cloud service platform. Our video solutions have been installed in more than 120 countries at thousands of customer sites, including school campuses, transportation systems, healthcare centres, public venues, critical infrastructure, prisons, factories, casinos, airports, financial institutions, government facilities and retailers.<br><br>At Motorola Solutions, you will find a culture of thought-leaders who are passionate about creating exciting new solutions for security and surveillance. We seek problem-solvers who are eager to rise to the challenges of a continuously evolving technological industry, and those who want to make an impact on the safety of people and businesses globally.<h2><br>Job Description</h2><p><b>Overview:</b></p><p><span>Motorola Solutions Video Security &amp; Access Control division is hiring a Technical Support Engineer for its industry leading, disruptive Cloud Video platforms. Reporting to a Technical Support Team Lead, the Technical Support Engineer ensures critical customer issues are resolved quickly and accurately. Success in this role will be defined by: a strong customer-oriented mentality, a thorough systematic approach to troubleshooting, and the curiosity to learn about a diverse set of technologies. </span></p><p></p><p><b><b>Responsibilities:</b></b></p><ul><li><p><span>Learn and maintain a strong understanding of Motorola Solutions cloud software and products, including CCTV cameras, access control hardware, cloud software, mobile applications, servers and networks.</span></p></li><li><p><span>Troubleshoot Motorola Solutions hardware and software products over the phone, via live-chat, email and through remote sessions</span></p></li><li><p><span>Concisely document software, hardware, and network information in a case management system. </span></p></li><li><p><span>Provide an exceptional customer experience during calls, emails, chat, and customer escalations.</span></p></li><li><p><span>Prioritise between tasks, including inbound calls, live chat and email requests, as well as working on existing case management, and recreating behaviour.</span></p></li><li><p><span>Collaborate with the regional and global support teams to provide a high quality and effective customer experience</span></p></li><li><p><span>Be flexible to work on call for after hours and weekend support if required.</span></p></li><li><p><span>Continuously learn new skills, technologies &amp; products; keeping up with Motorola Solutions&#39; pace of innovation.</span></p></li><li><p><span>Resolve clients&#39; software or hardware issues by troubleshooting and diagnosing network and data problems, including utilising diagnostic tools, exporting debug logs, analysing log files, and reporting escalations to engineering.</span></p></li></ul><h2><br>Basic Requirements</h2><p><b>Requirements:</b></p><ul><li><p><span>Strong problem solving, organisational and analytical skills, with demonstrated ability to resolve customer issues in the shortest time at the highest quality.</span></p></li><li><p><span>Ability to read, write, and speak English fluently; w</span><span>ith well developed interpersonal communication (written and oral) skills and the ability to document and explain complex technical problems and solutions to customers of all skill levels, while being personable.</span></p></li><li><p><span>A self-starter who can work independently as well as collaborate effectively with team members with minimal supervision.  Agile, resourceful learner with strong attention to detail.</span></p></li><li><p><span>Ability to keep grace under pressure, multitask and prioritise based on business needs, provide timely updates, manage customer expectations and handle complex situations while troubleshooting critical issues &amp; maintaining effective communication with all stakeholders.</span></p></li><li><p><span>Demonstrates a continuous learning mindset to digest the technical details of an ever evolving product line.</span></p></li><li><p><span>Critical problem solving mindset with the ability to collect relevant data and reviewing basic logs to identify potential root causes.</span></p></li><li><p><span>Ability to replicate problems in a lab environment</span></p></li></ul><p></p><p><b>Candidates must be able to display a working knowledge with:</b></p><ul><li><p><span>Applying technical concepts to troubleshooting procedures</span></p></li><li><p><span>Installing, configuring, and troubleshooting various operating systems, software, and hardware.</span></p></li><li><p><span>Some knowledge of networking products and technologies (such as; TCP/IP, Ethernet, VoIP, Switches and Video Surveillance cameras/ Video Conferencing hardware).</span></p></li></ul><p></p><p><b>Preference will be given to candidates with the following skills and experience:</b></p><p></p><ul><li><p><span>Some relevant technical experience in any of the following business areas - Video Security, Analytics, Access Control, Telecommunication, Video Conferencing, Cloud software or Enterprise hardware support.</span></p></li><li><p><span>Degree/Diploma in Computer Engineering, Computer Information Systems, Computer Science or equivalent.</span></p></li><li><p><span>Certifications such as, but not limited to: CCNA, CCNP, MCSA, MTA, LFS, MCSE, CompTIA A&#43;.</span></p></li><li><p><span>A familiarity with the Onvif profile or other video streaming services.</span></p></li><li><p><span>Multi language proficiency.</span></p></li><li><p><span>Experience working in environments using the KCS Methodology.</span></p></li><li><p><span>Experience using CRM (Customer Relationship Management) systems.</span></p><p></p></li></ul><p><b>In return for your expertise, we’ll support you in this new challenge with coaching &amp; development every step of the way. Also, to reward your hard work you’ll get:</b></p><ul><li><p>Competitive salary and bonus schemes</p></li><li><p>Two weeks additional pay per year (holiday bonus)</p></li><li><p>25 days holiday entitlement &#43; bank holidays  </p></li><li><p>Attractive defined contribution pension scheme</p></li><li><p>Private medical insurance </p></li><li><p>Employee stock purchase plan</p></li><li><p>Flexible working options </p></li><li><p>Life assurance  </p></li><li><p>Enhanced maternity and paternity pay</p></li><li><p>Career development support and wide ranging learning opportunities</p></li><li><p>Employee health and wellbeing support EAP, wellbeing guidance etc</p></li><li><p>Carbon neutral initiatives/goals</p></li><li><p>Corporate social responsibility initiatives including support for volunteering days</p></li><li><p>Well known companies discount scheme</p></li></ul><p></p><p>#LI-AR1</p><h2><br>Travel Requirements</h2>10-25%<h2><br>Relocation Provided</h2>None<h2><br>Position Type</h2>Experienced<p style=\"text-align:inherit\"></p><h2>Referral Payment Plan</h2>Yes<p style=\"text-align:inherit\"></p><h2><b>Company</b></h2>Motorola Solutions UK Limited<p></p><p><i><b>EEO Statement</b></i></p><p></p><p><span>Motorola Solutions is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion or belief, sex, sexual orientation, gender identity, national origin, disability, veteran status or any other legally-protected characteristic. </span></p><p></p><p><span>We are proud of our people-first and community-focused culture, empowering every Motorolan to be their most authentic self and to do their best work to deliver on the promise of a safer world. If you’d like to join our team but feel that you don’t quite meet all of the preferred skills, we’d still love to hear why you think you’d be a great addition to our team.</span></p><p></p><p><span>We’re committed to providing an inclusive and accessible recruiting experience for candidates with disabilities, or other physical or mental health conditions. To request an accommodation, please email </span><a href=\"mailto:ohr&#64;motorolasolutions.com\" target=\"_blank\"><span>ohr&#64;motorolasolutions.com</span></a>.</p>","location":"United Kingdom Offsite (ZUK99)","postedOn":"Posted Yesterday","startDate":"2024-07-29","timeType":"Full time","jobReqId":"R48704","jobPostingId":"Technical-Support-Specialist_R48704","jobPostingSiteId":"Careers","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7"},"canApply":true,"posted":true,"includeResumeParsing":true,"jobRequisitionLocation":{"descriptor":"United Kingdom Offsite (ZUK99)","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","alpha2Code":"GB"}},"externalUrl":"https://motorolasolutions.wd5.myworkdayjobs.com/Careers/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704","questionnaireId":"a5be17decf0a100143593b79a2310000","secondaryQuestionnaireId":"088e7c9c80bf1001f0d143420d020000"},"hiringOrganization":{"name":"908000 Motorola Solutions UK Limited","url":""},"similarJobs":[],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:44 GMT
 - request:
     method: post
     uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
@@ -1099,9 +511,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 29 Jul 2024 09:14:45 GMT
+      - Tue, 30 Jul 2024 16:26:45 GMT
       Etag:
-      - W/"1722244485376"
+      - W/"1722356805518"
       Server:
       - openresty
       X-Cb-Engine:
@@ -1113,11 +525,11 @@ http_interactions:
       X-Cb-Engine-Page-Count:
       - '1'
       X-Cb-Engine-Took:
-      - '6'
+      - '5'
       X-Cb-Engine-Total-Count:
       - '4'
       X-Cb-Request-Took:
-      - '15'
+      - '21'
       Content-Length:
       - '603'
       Connection:
@@ -1128,11 +540,11 @@ http_interactions:
         Solutions","identifier":{"permalink":"motorola-solutions","image_id":"v1470312559/vu37o8t5k4xdhtonwpxx.png","uuid":"d65bcbfb-b94e-e848-a953-bcd89ab7de00","entity_def_id":"organization","value":"Motorola
         Solutions"},"linkedin":{"value":"http://www.linkedin.com/company/motorolasolutions"},"short_description":"Motorola
         Solutions creates mission-critical communication solutions and services for
-        public safety and commercial customers.","rank_org":328,"website_url":"http://www.motorolasolutions.com"}}]}'
-  recorded_at: Mon, 29 Jul 2024 09:14:45 GMT
+        public safety and commercial customers.","rank_org":336,"website_url":"http://www.motorolasolutions.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 16:26:45 GMT
 - request:
     method: get
-    uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/job/Customer-Service---IT-Advisor_R48791
+    uri: https://motorolasolutions.wd5.myworkdayjobs.com/wday/cxs/motorolasolutions/Careers/job/Technical-Support-Specialist_R48704
     body:
       encoding: US-ASCII
       string: ''
@@ -1149,7 +561,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:46 GMT
+      - Tue, 30 Jul 2024 16:26:46 GMT
       Content-Type:
       - application/json
       Transfer-Encoding:
@@ -1163,44 +575,44 @@ http_interactions:
       Expires:
       - Thu, 1 Jan 1970 00:00:00 UTC
       Set-Cookie:
-      - PLAY_SESSION=c813b0589a38ca8daab1770d1ade635a079112fa-instance=vps-prod-8xpr1l8h.prod-vps.pr501.cust.pdx.wd;
+      - PLAY_SESSION=db41414e9dc7556e5e69ce769c1d05ef687842a9-instance=vps-prod-dc90h1lm.prod-vps.pr502.cust.pdx.wd;
         SameSite=Lax; Path=/; Secure; HTTPOnly
-      - __cf_bm=Z6SAPhEDTJysaXE10KfwFRbJwrXjfTlBUkhCk64alC4-1722244486-1.0.1.1-ih3by4YcnAsWT5sCfJKwivXcjG__1CvRV7iDr8g7swYiZ19J584AkQSXAPqL0nTckFpOeGCHTQ_viZ0Z9ZaElQ;
-        path=/; expires=Mon, 29-Jul-24 09:44:46 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
+      - __cf_bm=5TLyOiK0zsSxV806fcKP_7bjOZpikch0r_G9CtQdy7o-1722356806-1.0.1.1-9qUzBcwQy_NJXoypNdTAbXsdMj2ph_wV3p2gcU7sre8yrjeeWkb_a6ILqTDfdJdQkTiNzKy0z2ncLzzmGoHOrQ;
+        path=/; expires=Tue, 30-Jul-24 16:56:46 GMT; domain=.motorolasolutions.wd5.myworkdayjobs.com;
         HttpOnly; Secure; SameSite=None
-      - __cflb=02DiuHJZe28xXz6hQKNFTtNTjdFAZDpBKdNTotsAYpGTW; SameSite=None; Secure;
-        path=/; expires=Tue, 30-Jul-24 08:14:46 GMT; HttpOnly
-      - _cfuvid=kzVhBeNaGthBoZU.2pcuj02uHb8oJ7GJ85.iLLCy6ls-1722244486154-0.0.1.1-604800000;
+      - __cflb=02DiuHJZe28xXz6hQKLeTYyWYf7NxYcM1bUZTGcmTb7Lp; SameSite=None; Secure;
+        path=/; expires=Wed, 31-Jul-24 15:26:46 GMT; HttpOnly
+      - _cfuvid=lrR1Pc1ewaoJ7b5PtgiGOLrri0Sr7Rit7rioH7j5G7Y-1722356806189-0.0.1.1-604800000;
         path=/; domain=.motorolasolutions.wd5.myworkdayjobs.com; HttpOnly; Secure;
         SameSite=None
-      - wd-browser-id=7c3b4088-9347-4313-bf18-5563ab12c14f; Path=/; Secure; HTTPOnly
-      - wday_vps_cookie=652909578.53810.0000; path=/; Httponly; Secure; SameSite=none
+      - wd-browser-id=71ef3b0e-e671-4e74-9282-94baa9676daa; Path=/; Secure; HTTPOnly
+      - wday_vps_cookie=3186400266.53810.0000; path=/; Httponly; Secure; SameSite=none
       Cache-Control:
       - no-store, no-cache
       X-Wd-Request-Id:
-      - VPS|5ec05d7b-2718-41e7-8ca4-ab7906b0bd0c
+      - VPS|bef5cf4e-0ccd-4d30-9422-babd912de2a1
       Strict-Transport-Security:
       - max-age=31536000; includeSubDomains
       Cf-Cache-Status:
       - BYPASS
       Report-To:
-      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=EyXGpNZMlrvS8wGWWb4K74G%2Fbb65qHwYH%2FpLxAXtFjhaUEJ3zh7Gx7YuPNrww7QYKkyM3pnnhLyd1zulp5UporXcIAbwKKQ46fMraQVLdwAlIvGZKvFpktoje1RzCgEgnIGyvd07WUjOzTZFEpGRQeZ7VLFzGfPwTA%3D%3D"}],"group":"cf-nel","max_age":604800}'
+      - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=IiCvNNCCEJ06cZX8au0yFMwhCmV8qrjM6EtrR244odFge7L17P5ZO9xlEBLPym3PfTuNwmykgcRwQRpe0g3fBXf%2BbYIZjTuaxiJBXWBM%2FhNr8xG3hgTfi5juNxIDUXl%2FysaZxuyhT4NfY4bOdJaA%2FGDR0ayNvTw%2FcA%3D%3D"}],"group":"cf-nel","max_age":604800}'
       Nel:
       - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}'
       Server:
       - cloudflare
       Cf-Ray:
-      - 8aac00243a4c4380-EWR
+      - 8ab6b654da200cba-EWR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"jobPostingInfo":{"id":"0534f03727521000a37ba343a8f50000","title":"Customer Service & IT Advisor","jobDescription":"<h2><b>Company Overview</b></h2><p style=\"text-align:left\"><span>At Motorola Solutions, we&#39;re guided by a shared purpose - helping people be their best in the moments that matter - and we live up to our purpose every day by solving for safer. Because people can only be their best when they not only feel safe, but are safe. We&#39;re solving for safer by building the best possible technologies across every part of our safety and security ecosystem. That&#39;s mission-critical communications devices and networks, AI-powered video security &amp; access control and the ability to unite voice, video and data in a single command center view. We&#39;re solving for safer by connecting public safety agencies and enterprises, enabling the collaboration that&#39;s critical to connect those in need with those who can help. The work we do here matters.</span></p><h2><br /><b>Department Overview</b></h2>To deliver excellent Customer Service to Motorola Customers through effective and professional handing of Customer Incidents, Service Requests, Queries, Complaints and Internal IT issues received via telephone, email or Service Management Terminal.<br><br>This is the Motorola first point of contact and is in place to deliver first class service through effective resolution of incidents, and to proactively build an ongoing relationship with the customer. The role holder will understand and respond to the customer needs professionally.<h2><br>Job Description</h2><p><b>This role is also based onsite out of our Rugby office 5 days a week.</b></p><p></p><p><b>This role will require SC and NPPV3 security clearance which includes living in the UK for at least the past 5 years.</b></p><p></p><p>The role holder will develop and grow the skills required to support future products and services offered by Motorola including data products This is achieved through:</p><p></p><p>Development, improvement and adherence to, industry leading processes, procedures and best practices. Consistent delivery against agreed OLAs/KPIs and operational targets and Service Levels.</p><p></p><p>The delivery of a high quality and effective service management standard within the respective support procedures and activities.</p><p></p><p>The actions taken by this role and responsibility to the wider organisation will directly influence the customer &amp; desire to continue to employ the Motorola Services. The actions taken in this role and responsibility to the wider organisation will directly reflect in the Pulse of the Customer scores and the perception of Motorola&#39;s ability to manage customer contractual obligations and maintain excellent service.</p><p></p><p>The role holder will strive to achieve the customer service standards and targets that are agreed and documented in our customer contracts and meet high standards of operational excellence and delivery of quality. If this role did not exist then there would be no first line contact and diagnostic support for our customers.</p><p></p><p><b>Key Tasks:</b></p><p>• Customer Ingress and liaison by Phone, Email and Service Management Systems.</p><p>• Triage Incidents and Requests at a 1st line level, resolving at 1st line where possible.</p><p>• Use BMC Remedy to record, assign, monitor and update cases.</p><p>• Liaise with Suppliers for timely updates and co-ordinate responses.</p><p>• Progress and track orders through their life cycle to delivery.</p><p>• Monitor the jeopardy status and progress of cases.</p><p>• Escalate failure and risk to service level achievement.</p><p>• Ensure quality and accuracy of case data, identifying &amp; supporting Continual Service Improvement.</p><p></p><p>The role requires strength in organisation, collaboration, communication, negotiation, service delivery, influencing and the ability to deal with difficult customers.</p><p></p><p>Ability to develop and maintain strong working relationships within and outside the service desk environment.</p><p></p><p>Have demonstrable service desk experience and be able to evidence the ability to operate successfully in a demanding environment, whilst maintaining high morale, high achievement and actively supporting the collaborative culture that drives success.</p><p></p><p>Proactive approach to removing barriers and finding solutions to problems.</p><p>Flexible approach to operational demands and situations due to the changing nature of the role.</p><h2><br>Basic Requirements</h2><p><b>Basic Requirements</b></p><p>• Analytical skills and disciplined approach to resolving complex issues</p><p>• Able to improve processes and procedures</p><p>• Communication skills: Verbal, Written, Listening, and Questioning.</p><p>• Personal organisational skills</p><p>• The ability to influence and negotiate with internal and external parties</p><p>• Customer Focus</p><p>• Able to deal with change</p><p>• Ability to embrace new technologies</p><p>• Self motivated and enthusiastic</p><p>• Problem solving and fact-finding skills</p><p></p><p><b>Core competencies</b></p><p>• Proven ability in communication, both written and verbal</p><p>• Experience of working in a call centre or service centre environment</p><p>• Proficient in Computer systems and packages.</p><p>• Experience of working self-sufficiently and in a team environment delivering customer service</p><p>• ITIL V4 Foundation Qualification would be desirable.</p><p></p><p><b>In return for your expertise, we’ll support you in this new challenge with coaching and development every step of the way. Also, to reward your hard work you’ll get:</b></p><ul><li>Competitive salary and bonus schemes.</li><li>Two weeks additional pay per year (holiday bonus).</li><li>25 days holiday entitlement &#43; bank holidays. </li><li>Attractive defined contribution pension scheme.</li><li>Employee stock purchase plan.</li><li>Life assurance.</li><li>Enhanced maternity and paternity pay.</li><li>Career development support and wide ranging learning opportunities.</li><li>Employee health and wellbeing support EAP, wellbeing guidance etc.</li><li>Carbon neutral initiatives/goals.</li><li>Corporate social responsibility initiatives including support for volunteering days.</li><li>Well known companies discount scheme.</li></ul><p>#LI-KTB</p><h2><br>Travel Requirements</h2>Under 10%<h2><br>Relocation Provided</h2>None<h2><br>Position Type</h2>Experienced<p style=\"text-align:inherit\"></p><h2>Referral Payment Plan</h2>Yes<p style=\"text-align:inherit\"></p><h2><b>Company</b></h2>Airwave Solutions Limited<p></p><p><i><b>EEO Statement</b></i></p><p></p><p><span>Motorola Solutions is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion or belief, sex, sexual orientation, gender identity, national origin, disability, veteran status or any other legally-protected characteristic. </span></p><p></p><p><span>We are proud of our people-first and community-focused culture, empowering every Motorolan to be their most authentic self and to do their best work to deliver on the promise of a safer world. If you’d like to join our team but feel that you don’t quite meet all of the preferred skills, we’d still love to hear why you think you’d be a great addition to our team.</span></p><p></p><p><span>We’re committed to providing an inclusive and accessible recruiting experience for candidates with disabilities, or other physical or mental health conditions. To request an accommodation, please email </span><a href=\"mailto:ohr&#64;motorolasolutions.com\" target=\"_blank\"><span>ohr&#64;motorolasolutions.com</span></a>.</p>","location":"Rugby, UK (ZUK107)","postedOn":"Posted Today","startDate":"2024-07-29","timeType":"Full time","jobReqId":"R48791","jobPostingId":"Customer-Service---IT-Advisor_R48791","jobPostingSiteId":"Careers","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7"},"canApply":true,"posted":true,"includeResumeParsing":true,"jobRequisitionLocation":{"descriptor":"Rugby, UK (ZUK107)","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","alpha2Code":"GB"}},"externalUrl":"https://motorolasolutions.wd5.myworkdayjobs.com/Careers/job/Rugby-UK-ZUK107/Customer-Service---IT-Advisor_R48791","questionnaireId":"a5be17decf0a100143593b79a2310000","secondaryQuestionnaireId":"088e7c9c80bf1001f0d143420d020000"},"hiringOrganization":{"name":"908250 Airwave Solutions Limited","url":""},"similarJobs":[],"userAuthenticated":false}
-  recorded_at: Mon, 29 Jul 2024 09:14:46 GMT
+        {"jobPostingInfo":{"id":"0534f03727521000b18e611ec37e0000","title":"Technical Support Specialist","jobDescription":"<h2><b>Company Overview</b></h2><p style=\"text-align:left\"><span>At Motorola Solutions, we&#39;re guided by a shared purpose - helping people be their best in the moments that matter - and we live up to our purpose every day by solving for safer. Because people can only be their best when they not only feel safe, but are safe. We&#39;re solving for safer by building the best possible technologies across every part of our safety and security ecosystem. That&#39;s mission-critical communications devices and networks, AI-powered video security &amp; access control and the ability to unite voice, video and data in a single command center view. We&#39;re solving for safer by connecting public safety agencies and enterprises, enabling the collaboration that&#39;s critical to connect those in need with those who can help. The work we do here matters.</span></p><h2><br /><b>Department Overview</b></h2>Motorola Solutions is a global leader in mission-critical communications and analytics. Our technology platforms in mission-critical communications, command center software and video security &amp; analytics, make cities safer as well as help communities and businesses thrive. At Motorola Solutions, we are ushering in a new era in public safety and security. Motorola Solution’s Video Division is defining the future of the security industry through innovative end-to-end-solutions and award-winning AI based surveillance systems. Artificial Intelligence is transforming the world and our team is advancing the field as it applies to the surveillance industry. We are proud to be industry leaders in video analytics with products like Appearance Search and Unusual Motion Detection along with our cloud service platform. Our video solutions have been installed in more than 120 countries at thousands of customer sites, including school campuses, transportation systems, healthcare centres, public venues, critical infrastructure, prisons, factories, casinos, airports, financial institutions, government facilities and retailers.<br><br>At Motorola Solutions, you will find a culture of thought-leaders who are passionate about creating exciting new solutions for security and surveillance. We seek problem-solvers who are eager to rise to the challenges of a continuously evolving technological industry, and those who want to make an impact on the safety of people and businesses globally.<h2><br>Job Description</h2><p><b>Overview:</b></p><p><span>Motorola Solutions Video Security &amp; Access Control division is hiring a Technical Support Engineer for its industry leading, disruptive Cloud Video platforms. Reporting to a Technical Support Team Lead, the Technical Support Engineer ensures critical customer issues are resolved quickly and accurately. Success in this role will be defined by: a strong customer-oriented mentality, a thorough systematic approach to troubleshooting, and the curiosity to learn about a diverse set of technologies. </span></p><p></p><p><b><b>Responsibilities:</b></b></p><ul><li><p><span>Learn and maintain a strong understanding of Motorola Solutions cloud software and products, including CCTV cameras, access control hardware, cloud software, mobile applications, servers and networks.</span></p></li><li><p><span>Troubleshoot Motorola Solutions hardware and software products over the phone, via live-chat, email and through remote sessions</span></p></li><li><p><span>Concisely document software, hardware, and network information in a case management system. </span></p></li><li><p><span>Provide an exceptional customer experience during calls, emails, chat, and customer escalations.</span></p></li><li><p><span>Prioritise between tasks, including inbound calls, live chat and email requests, as well as working on existing case management, and recreating behaviour.</span></p></li><li><p><span>Collaborate with the regional and global support teams to provide a high quality and effective customer experience</span></p></li><li><p><span>Be flexible to work on call for after hours and weekend support if required.</span></p></li><li><p><span>Continuously learn new skills, technologies &amp; products; keeping up with Motorola Solutions&#39; pace of innovation.</span></p></li><li><p><span>Resolve clients&#39; software or hardware issues by troubleshooting and diagnosing network and data problems, including utilising diagnostic tools, exporting debug logs, analysing log files, and reporting escalations to engineering.</span></p></li></ul><h2><br>Basic Requirements</h2><p><b>Requirements:</b></p><ul><li><p><span>Strong problem solving, organisational and analytical skills, with demonstrated ability to resolve customer issues in the shortest time at the highest quality.</span></p></li><li><p><span>Ability to read, write, and speak English fluently; w</span><span>ith well developed interpersonal communication (written and oral) skills and the ability to document and explain complex technical problems and solutions to customers of all skill levels, while being personable.</span></p></li><li><p><span>A self-starter who can work independently as well as collaborate effectively with team members with minimal supervision.  Agile, resourceful learner with strong attention to detail.</span></p></li><li><p><span>Ability to keep grace under pressure, multitask and prioritise based on business needs, provide timely updates, manage customer expectations and handle complex situations while troubleshooting critical issues &amp; maintaining effective communication with all stakeholders.</span></p></li><li><p><span>Demonstrates a continuous learning mindset to digest the technical details of an ever evolving product line.</span></p></li><li><p><span>Critical problem solving mindset with the ability to collect relevant data and reviewing basic logs to identify potential root causes.</span></p></li><li><p><span>Ability to replicate problems in a lab environment</span></p></li></ul><p></p><p><b>Candidates must be able to display a working knowledge with:</b></p><ul><li><p><span>Applying technical concepts to troubleshooting procedures</span></p></li><li><p><span>Installing, configuring, and troubleshooting various operating systems, software, and hardware.</span></p></li><li><p><span>Some knowledge of networking products and technologies (such as; TCP/IP, Ethernet, VoIP, Switches and Video Surveillance cameras/ Video Conferencing hardware).</span></p></li></ul><p></p><p><b>Preference will be given to candidates with the following skills and experience:</b></p><p></p><ul><li><p><span>Some relevant technical experience in any of the following business areas - Video Security, Analytics, Access Control, Telecommunication, Video Conferencing, Cloud software or Enterprise hardware support.</span></p></li><li><p><span>Degree/Diploma in Computer Engineering, Computer Information Systems, Computer Science or equivalent.</span></p></li><li><p><span>Certifications such as, but not limited to: CCNA, CCNP, MCSA, MTA, LFS, MCSE, CompTIA A&#43;.</span></p></li><li><p><span>A familiarity with the Onvif profile or other video streaming services.</span></p></li><li><p><span>Multi language proficiency.</span></p></li><li><p><span>Experience working in environments using the KCS Methodology.</span></p></li><li><p><span>Experience using CRM (Customer Relationship Management) systems.</span></p><p></p></li></ul><p><b>In return for your expertise, we’ll support you in this new challenge with coaching &amp; development every step of the way. Also, to reward your hard work you’ll get:</b></p><ul><li><p>Competitive salary and bonus schemes</p></li><li><p>Two weeks additional pay per year (holiday bonus)</p></li><li><p>25 days holiday entitlement &#43; bank holidays  </p></li><li><p>Attractive defined contribution pension scheme</p></li><li><p>Private medical insurance </p></li><li><p>Employee stock purchase plan</p></li><li><p>Flexible working options </p></li><li><p>Life assurance  </p></li><li><p>Enhanced maternity and paternity pay</p></li><li><p>Career development support and wide ranging learning opportunities</p></li><li><p>Employee health and wellbeing support EAP, wellbeing guidance etc</p></li><li><p>Carbon neutral initiatives/goals</p></li><li><p>Corporate social responsibility initiatives including support for volunteering days</p></li><li><p>Well known companies discount scheme</p></li></ul><p></p><p>#LI-AR1</p><h2><br>Travel Requirements</h2>10-25%<h2><br>Relocation Provided</h2>None<h2><br>Position Type</h2>Experienced<p style=\"text-align:inherit\"></p><h2>Referral Payment Plan</h2>Yes<p style=\"text-align:inherit\"></p><h2><b>Company</b></h2>Motorola Solutions UK Limited<p></p><p><i><b>EEO Statement</b></i></p><p></p><p><span>Motorola Solutions is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion or belief, sex, sexual orientation, gender identity, national origin, disability, veteran status or any other legally-protected characteristic. </span></p><p></p><p><span>We are proud of our people-first and community-focused culture, empowering every Motorolan to be their most authentic self and to do their best work to deliver on the promise of a safer world. If you’d like to join our team but feel that you don’t quite meet all of the preferred skills, we’d still love to hear why you think you’d be a great addition to our team.</span></p><p></p><p><span>We’re committed to providing an inclusive and accessible recruiting experience for candidates with disabilities, or other physical or mental health conditions. To request an accommodation, please email </span><a href=\"mailto:ohr&#64;motorolasolutions.com\" target=\"_blank\"><span>ohr&#64;motorolasolutions.com</span></a>.</p>","location":"United Kingdom Offsite (ZUK99)","postedOn":"Posted Yesterday","startDate":"2024-07-29","timeType":"Full time","jobReqId":"R48704","jobPostingId":"Technical-Support-Specialist_R48704","jobPostingSiteId":"Careers","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7"},"canApply":true,"posted":true,"includeResumeParsing":true,"jobRequisitionLocation":{"descriptor":"United Kingdom Offsite (ZUK99)","country":{"descriptor":"United Kingdom","id":"29247e57dbaf46fb855b224e03170bc7","alpha2Code":"GB"}},"externalUrl":"https://motorolasolutions.wd5.myworkdayjobs.com/Careers/job/United-Kingdom-Offsite-ZUK99/Technical-Support-Specialist_R48704","questionnaireId":"a5be17decf0a100143593b79a2310000","secondaryQuestionnaireId":"088e7c9c80bf1001f0d143420d020000"},"hiringOrganization":{"name":"908000 Motorola Solutions UK Limited","url":""},"similarJobs":[],"userAuthenticated":false}
+  recorded_at: Tue, 30 Jul 2024 16:26:46 GMT
 - request:
     method: get
-    uri: http://dev.virtualearth.net/REST/v1/Locations/Rugby,%20UK%20ZUK107%20)?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
+    uri: http://dev.virtualearth.net/REST/v1/Locations/United%20Kingdom?key=As9GK0TwxULCFyDaoq4D-Y69ba9KgY2PSUp3XopYkZuhJWWm_gYcGosV7sjd7b8l
     body:
       encoding: US-ASCII
       string: ''
@@ -1217,11 +629,11 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 29 Jul 2024 09:14:46 GMT
+      - Tue, 30 Jul 2024 16:26:46 GMT
       Content-Type:
       - application/json; charset=utf-8
       Content-Length:
-      - '2395'
+      - '1660'
       Connection:
       - keep-alive
       Access-Control-Allow-Headers:
@@ -1235,18 +647,18 @@ http_interactions:
       Cache-Control:
       - no-cache
       X-Bm-Traceid:
-      - 118414fb216324a82722aece09cc315b
+      - cb903dc0b5ecd9f337efb1eddc6111f0
       X-Msedge-Ref:
-      - 'Ref SnR: 66a75d86b54145e385562a428c7076df|Ref A: C1732BFF4EC74B00A37FC2A4F2AD64A6
-        Ref B: DB3EDGE2117 Ref C: 2024-07-29T09:14:46Z'
+      - 'Ref A: E466273E5F5B44239B9DB0E9ED1E62C7 Ref B: DB3EDGE2519 Ref C: 2024-07-30T16:26:46Z|Ref
+        SnR: 66a91446e10f4af593a95825a1a9d5a3'
       X-Bm-Srv:
-      - mapsplatform-frontend-5989d449fd-4c4wh, mapsplatform-forwardgeocoder-service-69c675d4f5-vdxvd
+      - mapsplatform-frontend-5989d449fd-zk7ph, mapsplatform-forwardgeocoder-service-69c675d4f5-9fk55
       X-Ms-Bm-Ws-Info:
       - '0'
       X-Bm-Fe-Elapsed:
-      - '68'
+      - '74'
       X-Azure-Ref:
-      - 20240729T091446Z-17cc7bff758tcp750hmt79n2nn00000005mg00000000ceg7
+      - 20240730T162646Z-17cc7bff758528960avxuywf2s00000002m0000000005ye1
       X-Cache:
       - CONFIG_NOCACHE
       Accept-Ranges:
@@ -1254,6 +666,6 @@ http_interactions:
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 29 Jul 2024 09:14:46 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 16:26:46 GMT
 recorded_with: VCR 6.2.0
diff --git a/spec/fixtures/cassettes/fetch_company_jobs_AshbyHQ.yml b/spec/fixtures/cassettes/fetch_company_jobs_AshbyHQ.yml
index 40b9ae21..a951ec93 100644
--- a/spec/fixtures/cassettes/fetch_company_jobs_AshbyHQ.yml
+++ b/spec/fixtures/cassettes/fetch_company_jobs_AshbyHQ.yml
@@ -19,7 +19,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 24 Jun 2024 10:47:35 GMT
+      - Tue, 30 Jul 2024 17:00:24 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -27,7 +27,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J14XQEX8Z0EJRNQ7YQYCF15K
+      - 01J429BZHAP66M5VR83774X6WK
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -43,14 +43,14 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 898c23ff189171a2-LHR
+      - 8ab6e79c9c463864-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"jobs":[{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">From time to time, we'll expect you to produce content or present to our community. We're big believers in engaging with our community as much as possible.</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - From time to time, we'll expect you to produce content or present to our community. We're big believers in engaging with our community as much as possible.\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
-  recorded_at: Mon, 24 Jun 2024 10:47:35 GMT
+        {"jobs":[{"id":"309706bc-1081-48b6-89dc-f769bbe17e6d","title":"Analytics Engineering Advocate","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-07-15T16:45:14.721+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d","applyUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d/application","descriptionHtml":"<h2>About Lightdash</h2><p style=\"min-height:1.5em\">Lightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.</p><p style=\"min-height:1.5em\">We’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.</p><p style=\"min-height:1.5em\">We’re helping data teams build data-driven companies so they can make better decisions, faster.</p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><h2>About the role</h2><p style=\"min-height:1.5em\">At Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.</p><p style=\"min-height:1.5em\">Our users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.</p><p style=\"min-height:1.5em\"></p><h2><strong>Areas of Responsibility:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>Obsess over the success of our users:</strong> Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.</p></li><li><p style=\"min-height:1.5em\"><strong>Lightdash champion:</strong> You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash <em><strong>at</strong></em> Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.</p></li><li><p style=\"min-height:1.5em\"><strong>Teach and share:</strong> Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.</p></li><li><p style=\"min-height:1.5em\"><strong>Community strategy:</strong> Building and executing strategies to grow and engage the analyst community around Lightdash.</p></li></ul><h2><strong>Requirements:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Experience with business intelligence and analytics engineering</p></li><li><p style=\"min-height:1.5em\">Strong verbal and written communication skills</p></li><li><p style=\"min-height:1.5em\">Comfortable with dbt, SQL, git, data visualization, and the command line</p></li></ul><h2><strong>KPIs owned by the role (WIP):</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Community size and engagement</p></li><li><p style=\"min-height:1.5em\">Customer support response times and NPS</p></li><li><p style=\"min-height:1.5em\">Content published and hits</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"ABOUT LIGHTDASH\n\nLightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.\n\nWe’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.\n\nWe’re helping data teams build data-driven companies so they can make better decisions, faster.\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nABOUT THE ROLE\n\nAt Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.\n\nOur users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.\n\n\nAREAS OF RESPONSIBILITY:\n\n - Obsess over the success of our users: Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.\n\n - Lightdash champion: You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash at Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.\n\n - Teach and share: Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.\n\n - Community strategy: Building and executing strategies to grow and engage the analyst community around Lightdash.\n\n\nREQUIREMENTS:\n\n - Experience with business intelligence and analytics engineering\n\n - Strong verbal and written communication skills\n\n - Comfortable with dbt, SQL, git, data visualization, and the command line\n\n\nKPIS OWNED BY THE ROLE (WIP):\n\n - Community size and engagement\n\n - Customer support response times and NPS\n\n - Content published and hits\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £95K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £95K","compensationTiers":[{"id":"7cc7b9bb-3f87-4a9c-8e43-604566dbbb54","tierSummary":"£60K – £95K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"13d62bbc-1c15-4ff9-9480-feef72e9847a","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"id":"5c26b271-dd8b-4749-acd3-be1a3b94e870","summary":"£60K – £95K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}],"summaryComponents":[{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}},{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
+  recorded_at: Tue, 30 Jul 2024 17:00:24 GMT
 - request:
     method: post
     uri: https://jobs.ashbyhq.com/api/non-user-graphql?op=ApiOrganizationFromHostedJobsPageName
@@ -77,7 +77,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 24 Jun 2024 10:47:35 GMT
+      - Tue, 30 Jul 2024 17:00:24 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -85,7 +85,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J14XQF40ERWCFP3PTEWK0D4E
+      - 01J429BZVZAE8T2S3TK4YZ7B95
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -103,16 +103,16 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 898c24006f1871e1-LHR
+      - 8ab6e79eac3879b2-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
-      string: '{"data":{"organization":{"name":"Lightdash","publicWebsite":"https://www.lightdash.com/","customJobsPageUrl":null,"hostedJobsPageSlug":"Lightdash","allowJobPostIndexing":true,"appConfirmationTrackingPixelHtml":null,"recruitingPrivacyPolicyUrl":null,"activeFeatureFlags":["AnonymousCandidateExperience","JobPostingApplicationDeadlines","SchedulingNewAvailabileTimesCalculation","UnsubscribeLinks","VirusScanFiles","VirusScanShowResults"],"timezone":"Europe/London","__typename":"Organization","theme":{"colors":{"version":"1","colorPrimary600":"#7262FF","colorPrimary900":"#7262FF"},"showJobFilters":false,"showTeams":false,"showAutofillApplicationsBox":true,"applicationSubmittedSuccessMessage":null,"__typename":"Theme","logoWordmarkImageUrl":"https://app.ashbyhq.com/api/images/org-theme-wordmark/118a5d75-b907-4616-ade7-b67eaa6b5c16/314e7c4e-d0d9-494f-b7cd-7d008d80f41e.png","logoSquareImageUrl":"https://app.ashbyhq.com/api/images/org-theme-logo/118a5d75-b907-4616-ade7-b67eaa6b5c16/0e2997f7-6255-4c9e-9ea4-0199b51c80ef.png","jobBoardTopDescriptionHtml":null,"jobBoardBottomDescriptionHtml":null}}}}'
-  recorded_at: Mon, 24 Jun 2024 10:47:35 GMT
+      string: '{"data":{"organization":{"name":"Lightdash","publicWebsite":"https://www.lightdash.com/","customJobsPageUrl":null,"hostedJobsPageSlug":"Lightdash","allowJobPostIndexing":true,"appConfirmationTrackingPixelHtml":null,"recruitingPrivacyPolicyUrl":null,"activeFeatureFlags":["AnonymousCandidateExperience","JobPostingAlwaysReturnFormRenders","JobPostingApplicationDeadlines","SchedulingNewDirectBookingReschedule","SourcingFormAutoFill","UnsubscribeLinks","VirusScanFiles","VirusScanShowResults"],"timezone":"Europe/London","__typename":"Organization","theme":{"colors":{"version":"1","colorPrimary600":"#7262FF","colorPrimary900":"#7262FF"},"showJobFilters":false,"showTeams":false,"showAutofillApplicationsBox":true,"applicationSubmittedSuccessMessage":null,"__typename":"Theme","logoWordmarkImageUrl":"https://app.ashbyhq.com/api/images/org-theme-wordmark/118a5d75-b907-4616-ade7-b67eaa6b5c16/314e7c4e-d0d9-494f-b7cd-7d008d80f41e.png","logoSquareImageUrl":"https://app.ashbyhq.com/api/images/org-theme-logo/118a5d75-b907-4616-ade7-b67eaa6b5c16/0e2997f7-6255-4c9e-9ea4-0199b51c80ef.png","jobBoardTopDescriptionHtml":null,"jobBoardBottomDescriptionHtml":null}}}}'
+  recorded_at: Tue, 30 Jul 2024 17:00:24 GMT
 - request:
     method: post
-    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=1a809e14a0c7e29e964a5923f1b17bdd
+    uri: https://api.crunchbase.com/api/v4/searches/organizations?user_key=412884ba49f101427f2e0dc7007db5d0
     body:
       encoding: UTF-8
       string: '{"field_ids":["name","short_description","linkedin","website_url","rank_org"],"order":[{"field_id":"rank_org","sort":"asc"}],"query":[{"type":"predicate","field_id":"website_url","operator_id":"domain_eq","values":["https://www.lightdash.com/"]}],"limit":1}'
@@ -135,9 +135,9 @@ http_interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 24 Jun 2024 10:47:36 GMT
+      - Tue, 30 Jul 2024 17:00:25 GMT
       Etag:
-      - W/"1719226056613"
+      - W/"1722358825585"
       Server:
       - openresty
       X-Cb-Engine:
@@ -153,16 +153,16 @@ http_interactions:
       X-Cb-Engine-Total-Count:
       - '1'
       X-Cb-Request-Took:
-      - '19'
+      - '11'
       Content-Length:
-      - '486'
+      - '498'
       Connection:
       - keep-alive
     body:
       encoding: UTF-8
-      string: '{"count":1,"entities":[{"uuid":"301bce04-1610-4369-a9db-29de9623e65f","properties":{"name":"Lightdash","identifier":{"permalink":"hubble-e65f","image_id":"citkfzfr7esouu3essw6","uuid":"301bce04-1610-4369-a9db-29de9623e65f","entity_def_id":"organization","value":"Lightdash"},"linkedin":{"value":"https://www.linkedin.com/company/lightdash"},"short_description":"Lightdash
-        turns a dbt project into a full-stack BI platform.","rank_org":84585,"website_url":"https://www.lightdash.com"}}]}'
-  recorded_at: Mon, 24 Jun 2024 10:47:36 GMT
+      string: '{"count":1,"entities":[{"uuid":"301bce04-1610-4369-a9db-29de9623e65f","properties":{"name":"Lightdash","identifier":{"permalink":"hubble-e65f","image_id":"1c3c7ecd819e45879f8987babbbf2fea","uuid":"301bce04-1610-4369-a9db-29de9623e65f","entity_def_id":"organization","value":"Lightdash"},"linkedin":{"value":"https://www.linkedin.com/company/lightdash"},"short_description":"Lightdash
+        turns a dbt project into a full-stack BI platform.","rank_org":80511,"website_url":"https://www.lightdash.com"}}]}'
+  recorded_at: Tue, 30 Jul 2024 17:00:25 GMT
 - request:
     method: get
     uri: https://api.ashbyhq.com/posting-api/job-board/lightdash?includeCompensation=true
@@ -182,7 +182,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 24 Jun 2024 10:47:36 GMT
+      - Tue, 30 Jul 2024 17:00:25 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -190,7 +190,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J14XQG5K61NVRZBNVEZ88X1N
+      - 01J429C0T4P4E2E64PTH9H887P
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -206,29 +206,29 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 898c2406e8424165-LHR
+      - 8ab6e7a4ac0f9449-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        {"jobs":[{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">From time to time, we'll expect you to produce content or present to our community. We're big believers in engaging with our community as much as possible.</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - From time to time, we'll expect you to produce content or present to our community. We're big believers in engaging with our community as much as possible.\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
-  recorded_at: Mon, 24 Jun 2024 10:47:36 GMT
+        {"jobs":[{"id":"309706bc-1081-48b6-89dc-f769bbe17e6d","title":"Analytics Engineering Advocate","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-07-15T16:45:14.721+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d","applyUrl":"https://jobs.ashbyhq.com/lightdash/309706bc-1081-48b6-89dc-f769bbe17e6d/application","descriptionHtml":"<h2>About Lightdash</h2><p style=\"min-height:1.5em\">Lightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.</p><p style=\"min-height:1.5em\">We’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.</p><p style=\"min-height:1.5em\">We’re helping data teams build data-driven companies so they can make better decisions, faster.</p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><h2>About the role</h2><p style=\"min-height:1.5em\">At Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.</p><p style=\"min-height:1.5em\">Our users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.</p><p style=\"min-height:1.5em\"></p><h2><strong>Areas of Responsibility:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>Obsess over the success of our users:</strong> Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.</p></li><li><p style=\"min-height:1.5em\"><strong>Lightdash champion:</strong> You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash <em><strong>at</strong></em> Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.</p></li><li><p style=\"min-height:1.5em\"><strong>Teach and share:</strong> Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.</p></li><li><p style=\"min-height:1.5em\"><strong>Community strategy:</strong> Building and executing strategies to grow and engage the analyst community around Lightdash.</p></li></ul><h2><strong>Requirements:</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Experience with business intelligence and analytics engineering</p></li><li><p style=\"min-height:1.5em\">Strong verbal and written communication skills</p></li><li><p style=\"min-height:1.5em\">Comfortable with dbt, SQL, git, data visualization, and the command line</p></li></ul><h2><strong>KPIs owned by the role (WIP):</strong></h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Community size and engagement</p></li><li><p style=\"min-height:1.5em\">Customer support response times and NPS</p></li><li><p style=\"min-height:1.5em\">Content published and hits</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"ABOUT LIGHTDASH\n\nLightdash is an open source BI tool that instantly turns your dbt project into a full-stack BI platform.\n\nWe’re building the best BI tool for analytics engineers by letting them manage everything as code, from the comfort of their text editor and command line. Once the data team has written the metrics, then Lightdash enables self-serve for the entire business, so your data is accessible for the whole team.\n\nWe’re helping data teams build data-driven companies so they can make better decisions, faster.\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nABOUT THE ROLE\n\nAt Lightdash, we’re obsessed with the success of our users. Our fast and technical analytics support is one of our superpowers today. It covers everything from building dashboards and writing SQL to analytics engineering best practice. If you have a passion for helping teams win with data, we’re looking for an Analytics Engineering Advocate to join the Lightdash team.\n\nOur users’ experience of Lightdash goes beyond our product features and includes every touchpoint and interaction they have with the community and team. In this role, you’ll be the voice for our community and responsible for our users’ questions related to Lightdash, best practice in BI and analytics engineering.\n\n\nAREAS OF RESPONSIBILITY:\n\n - Obsess over the success of our users: Our users’ wins are our wins. We want to keep building on our technical support that our community and customers know and love. You’ll provide in-depth, personalised answers and pair program with users to solve their analytics problems and pull in other Lightdash team members when needed.\n\n - Lightdash champion: You’ll be the go-to Lightdash pro at Lightdash and in the community. You’ll keep up with our latest features and know how to use them (you’ll be using Lightdash at Lightdash regularly!) and you’ll make sure to share this knowledge with the community. You’ll also represent the company at community events, conferences, and meet ups.\n\n - Teach and share: Create and deliver world class tutorials and demos for Lightdash as well as examples of best-practice for data analytics. These could be blog posts, video tutorials, or code examples.\n\n - Community strategy: Building and executing strategies to grow and engage the analyst community around Lightdash.\n\n\nREQUIREMENTS:\n\n - Experience with business intelligence and analytics engineering\n\n - Strong verbal and written communication skills\n\n - Comfortable with dbt, SQL, git, data visualization, and the command line\n\n\nKPIS OWNED BY THE ROLE (WIP):\n\n - Community size and engagement\n\n - Customer support response times and NPS\n\n - Content published and hits\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £95K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £95K","compensationTiers":[{"id":"7cc7b9bb-3f87-4a9c-8e43-604566dbbb54","tierSummary":"£60K – £95K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"13d62bbc-1c15-4ff9-9480-feef72e9847a","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"id":"5c26b271-dd8b-4749-acd3-be1a3b94e870","summary":"£60K – £95K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}],"summaryComponents":[{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3},{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":95000}]}},{"id":"9efa292a-cc34-4388-90a2-2bed5126ace4","title":"Full Stack Engineer","department":"Lightdash","team":"Lightdash","employmentType":"FullTime","location":"Remote","shouldDisplayCompensationOnJobPostings":true,"secondaryLocations":[],"publishedAt":"2024-02-28T12:02:30.031+00:00","isListed":true,"isRemote":true,"address":{"postalAddress":{"addressCountry":"United Kingdom"}},"jobUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4","applyUrl":"https://jobs.ashbyhq.com/lightdash/9efa292a-cc34-4388-90a2-2bed5126ace4/application","descriptionHtml":"<p style=\"min-height:1.5em\">We're looking for a full-stack engineer to join our small and growing team.</p><p style=\"min-height:1.5em\">We value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.</p><p style=\"min-height:1.5em\"></p><h1>Some things we're looking for:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.</p></li><li><p style=\"min-height:1.5em\">You appreciate good design (UI/UX) and are passionate about building products that people love to use</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You have experience or an interest in open source projects</p></li><li><p style=\"min-height:1.5em\">You're thoughtful about creating and maintaining a world-class engineering culture</p></li></ul><p style=\"min-height:1.5em\"></p><h1>What the job involves:</h1><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Build and own features from start to finish: plan, build, test, deploy, iterate</p></li><li><p style=\"min-height:1.5em\">Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!</p></li><li><p style=\"min-height:1.5em\">Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work</p></li><li><p style=\"min-height:1.5em\">Having an ownership mindset: being comfortable with both responsibility and accountability</p></li><li><p style=\"min-height:1.5em\">You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!</p></li><li><p style=\"min-height:1.5em\">You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas</p></li><li><p style=\"min-height:1.5em\">You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”</p></li></ul><p style=\"min-height:1.5em\"><em>Research has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!</em></p><p style=\"min-height:1.5em\"></p><h2>How we work at Lightdash</h2><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\"><strong>We build in public, by default.</strong> We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the <em><strong>best</strong></em> decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.</p></li><li><p style=\"min-height:1.5em\"><strong>We challenge problems, not people.</strong> We ask ourselves “<em><strong>why</strong></em> is this broken?” not “<em><strong>who</strong></em> is breaking this?”</p></li><li><p style=\"min-height:1.5em\"><strong>We’re highly collaborative.</strong> We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.</p></li><li><p style=\"min-height:1.5em\"><strong>We bias towards impact.</strong> We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.</p></li></ul><p style=\"min-height:1.5em\"></p><h1>Our tech stack:</h1><p style=\"min-height:1.5em\">While we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:</p><ul style=\"min-height:1.5em\"><li><p style=\"min-height:1.5em\">Primary stack: Typescript, React, Node, SQL</p></li><li><p style=\"min-height:1.5em\">Frameworks: express, react-hooks</p></li><li><p style=\"min-height:1.5em\">Infrastructure: Docker, GCP</p></li></ul><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\"></p><p style=\"min-height:1.5em\">💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.</p>","descriptionPlain":"We're looking for a full-stack engineer to join our small and growing team.\n\nWe value small and high performing teams and are looking for a full-time software engineer to join alongside the current core team. The responsibilities will go beyond just the technical stack, and you'll be expected to contribute to the company strategy and will have a lot of influence over the product and company culture going forward.\n\n\nSOME THINGS WE'RE LOOKING FOR:\n\n - You have experience or interest in building interactive products that teams love: you're excited about building the most user-friendly products for teams to take their raw data and turn it into insights.\n\n - You appreciate good design (UI/UX) and are passionate about building products that people love to use\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You have experience or an interest in open source projects\n\n - You're thoughtful about creating and maintaining a world-class engineering culture\n\n\nWHAT THE JOB INVOLVES:\n\n - Build and own features from start to finish: plan, build, test, deploy, iterate\n\n - Work in a small high performing team with a lot of collaboration and getting feedback directly from our users!\n\n - Interacting with our users in the community (through Slack, Twitter or Github) and reviewing their issues and using the feedback to prioritise our work\n\n - Having an ownership mindset: being comfortable with both responsibility and accountability\n\n - You’re comfortable working in a new, small team that is rapidly growing – you’ll need to be comfortable when faced with a lot of ambiguity, both technically and organizationally!\n\n - You're a fantastic communicator, especially in a remote team and are happy to continuously challenge existing ideas\n\n - You feel confident making trade-off decisions between moving quickly and launching features versus optimizing for engineering excellence. You’re happy putting something out when it’s “80% done.”\n\nResearch has shown that women are less likely than men to apply for a role if they don’t have experience in 100% of the requirements outlined in a job description. Please know that even if you don’t have experience in all the areas above, but think you could do a great job and are excited about shaping company culture, finding great people and building great teams, we’d love to hear from you!\n\n\nHOW WE WORK AT LIGHTDASH\n\n - We build in public, by default. We’re an open source product, so having shared context is important so that people can contribute effectively to Lightdash. As a team, we also think that we make the best decisions when everyone has a lot of the same information. We don't oversell and under-deliver: we want the experience of using Lightdash to be as awesome as the experience we're selling.\n\n - We challenge problems, not people. We ask ourselves “why is this broken?” not “who is breaking this?”\n\n - We’re highly collaborative. We’re a group of people that are happy working independently, but love being part of a team. ****We not only work on problems as a team, but we also listen to the feedback from our community and our users. We invest in tools and processes that allow us to do this, even while fully remote.\n\n - We bias towards impact. We’d rather build something to 80% and get it in front of users so we can iterate on fast feedback than build something to 100% just to find out it’s not the right thing. We spend a lot of time thinking about how our work solves real user problems. We work on the highest impact problems even if they’re something a bit “out of your remit”.\n\n\nOUR TECH STACK:\n\nWhile we don't expect you to have used all the components of our stack, it'd be great to know which parts of it you're familiar with:\n\n - Primary stack: Typescript, React, Node, SQL\n\n - Frameworks: express, react-hooks\n\n - Infrastructure: Docker, GCP\n\n💜 We believe that to build a product that works for a diverse group of people, we need a diverse team. So, we strongly encourage candidates of all different perspectives, experiences, backgrounds and identities to apply. We’re committed to hiring people regardless of race, religion, colour, national origin, sex, sexual orientation, gender identity, age or disability. And once you join us, we’re committed to building an inclusive, supportive place for you to do the best work of your career.","compensation":{"compensationTierSummary":"£60K – £110K • 0.1% – 0.3%","scrapeableCompensationSalarySummary":"£60K - £110K","compensationTiers":[{"id":"15651751-fa53-4029-a8b9-277332d8a224","tierSummary":"£60K – £110K • 0.1% – 0.3%","title":null,"additionalInformation":null,"components":[{"id":"6d4cd99a-738f-4c3c-ba71-15f11cf91d24","summary":"£60K – £110K","compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"id":"08fa0dfd-940b-48e3-9149-afe32fa422b1","summary":"0.1% – 0.3%","compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}],"summaryComponents":[{"compensationType":"Salary","interval":"1 YEAR","currencyCode":"GBP","minValue":60000,"maxValue":110000},{"compensationType":"EquityPercentage","interval":"NONE","currencyCode":null,"minValue":0.1,"maxValue":0.3}]}}],"apiVersion":"1"}
+  recorded_at: Tue, 30 Jul 2024 17:00:25 GMT
 - request:
     method: post
-    uri: https://jobs.ashbyhq.com/api/non-user-graphql?op=ApiJobPosting
+    uri: https://jobs.ashbyhq.com/api/non-user-graphql
     body:
       encoding: UTF-8
       string: '{"query":"query ApiJobPosting($organizationHostedJobsPageName: String!,
         $jobPostingId: String!) {  jobPosting(    organizationHostedJobsPageName:
         $organizationHostedJobsPageName    jobPostingId: $jobPostingId  ) {    applicationForm
-        {      ...FormRenderParts      __typename    }    surveyForms {      ...FormRenderParts      __typename    }    applicationDeadline    __typename  }}fragment
+        {      ...FormRenderParts      __typename    }    surveyForms {      ...FormRenderParts      __typename    }    applicationDeadline    applicationLimitCalloutHtml    __typename  }}fragment
         JSONBoxParts on JSONBox {  value  __typename}fragment FileParts on File {  id  filename  __typename}fragment
         FormFieldEntryParts on FormFieldEntry {  id  field  fieldValue {    ... on
         JSONBox {      ...JSONBoxParts      __typename    }    ... on File {      ...FileParts      __typename    }    ...
         on FileList {      files {        ...FileParts        __typename      }      __typename    }    __typename  }  isRequired  descriptionHtml  isHidden  __typename}fragment
         FormRenderParts on FormRender {  id  formControls {    identifier    title    __typename  }  errorMessages  sections
-        {    fieldEntries {      ...FormFieldEntryParts      __typename    }    isHidden    __typename  }  sourceFormDefinitionId  __typename}","variables":{"jobPostingId":"9efa292a-cc34-4388-90a2-2bed5126ace4","organizationHostedJobsPageName":"lightdash"}}'
+        {    title    descriptionHtml    fieldEntries {      ...FormFieldEntryParts      __typename    }    isHidden    __typename  }  sourceFormDefinitionId  __typename}","variables":{"jobPostingId":"309706bc-1081-48b6-89dc-f769bbe17e6d","organizationHostedJobsPageName":"lightdash"}}'
     headers:
       Content-Type:
       - application/json
@@ -244,7 +244,7 @@ http_interactions:
       message: OK
     headers:
       Date:
-      - Mon, 24 Jun 2024 10:47:37 GMT
+      - Tue, 30 Jul 2024 17:00:26 GMT
       Content-Type:
       - application/json; charset=utf-8
       Transfer-Encoding:
@@ -252,7 +252,7 @@ http_interactions:
       Connection:
       - keep-alive
       X-Ashby-Request-Id:
-      - 01J14XQGH5R70E9781SS2H0PSY
+      - 01J429C144HRXZM9P0HP8D8S7M
       X-Content-Type-Options:
       - nosniff
       X-Frame-Options:
@@ -270,12 +270,332 @@ http_interactions:
       Server:
       - cloudflare
       Cf-Ray:
-      - 898c2409586163d7-LHR
+      - 8ab6e7a6ce876430-LHR
       Alt-Svc:
       - h3=":443"; ma=86400
     body:
       encoding: ASCII-8BIT
       string: !binary |-
-        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
-  recorded_at: Mon, 24 Jun 2024 10:47:37 GMT
+        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
+  recorded_at: Tue, 30 Jul 2024 17:00:26 GMT
+- request:
+    method: post
+    uri: https://jobs.ashbyhq.com/api/non-user-graphql
+    body:
+      encoding: UTF-8
+      string: '{"query":"query ApiJobPosting($organizationHostedJobsPageName: String!,
+        $jobPostingId: String!) {  jobPosting(    organizationHostedJobsPageName:
+        $organizationHostedJobsPageName    jobPostingId: $jobPostingId  ) {    applicationForm
+        {      ...FormRenderParts      __typename    }    surveyForms {      ...FormRenderParts      __typename    }    applicationDeadline    applicationLimitCalloutHtml    __typename  }}fragment
+        JSONBoxParts on JSONBox {  value  __typename}fragment FileParts on File {  id  filename  __typename}fragment
+        FormFieldEntryParts on FormFieldEntry {  id  field  fieldValue {    ... on
+        JSONBox {      ...JSONBoxParts      __typename    }    ... on File {      ...FileParts      __typename    }    ...
+        on FileList {      files {        ...FileParts        __typename      }      __typename    }    __typename  }  isRequired  descriptionHtml  isHidden  __typename}fragment
+        FormRenderParts on FormRender {  id  formControls {    identifier    title    __typename  }  errorMessages  sections
+        {    title    descriptionHtml    fieldEntries {      ...FormFieldEntryParts      __typename    }    isHidden    __typename  }  sourceFormDefinitionId  __typename}","variables":{"jobPostingId":"309706bc-1081-48b6-89dc-f769bbe17e6d","organizationHostedJobsPageName":"lightdash"}}'
+    headers:
+      Content-Type:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jul 2024 17:00:26 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      X-Ashby-Request-Id:
+      - 01J429C1F3VD18KYJPFBBMKN0X
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - DENY
+      Referrer-Policy:
+      - same-origin
+      Cache-Control:
+      - no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0
+      Access-Control-Allow-Origin:
+      - "*"
+      Cf-Cache-Status:
+      - DYNAMIC
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 8ab6e7a90d3076cf-LHR
+      Alt-Svc:
+      - h3=":443"; ma=86400
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        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
+  recorded_at: Tue, 30 Jul 2024 17:00:26 GMT
+- request:
+    method: post
+    uri: https://jobs.ashbyhq.com/api/non-user-graphql
+    body:
+      encoding: UTF-8
+      string: '{"query":"query ApiJobPosting($organizationHostedJobsPageName: String!,
+        $jobPostingId: String!) {  jobPosting(    organizationHostedJobsPageName:
+        $organizationHostedJobsPageName    jobPostingId: $jobPostingId  ) {    applicationForm
+        {      ...FormRenderParts      __typename    }    surveyForms {      ...FormRenderParts      __typename    }    applicationDeadline    applicationLimitCalloutHtml    __typename  }}fragment
+        JSONBoxParts on JSONBox {  value  __typename}fragment FileParts on File {  id  filename  __typename}fragment
+        FormFieldEntryParts on FormFieldEntry {  id  field  fieldValue {    ... on
+        JSONBox {      ...JSONBoxParts      __typename    }    ... on File {      ...FileParts      __typename    }    ...
+        on FileList {      files {        ...FileParts        __typename      }      __typename    }    __typename  }  isRequired  descriptionHtml  isHidden  __typename}fragment
+        FormRenderParts on FormRender {  id  formControls {    identifier    title    __typename  }  errorMessages  sections
+        {    title    descriptionHtml    fieldEntries {      ...FormFieldEntryParts      __typename    }    isHidden    __typename  }  sourceFormDefinitionId  __typename}","variables":{"jobPostingId":"309706bc-1081-48b6-89dc-f769bbe17e6d","organizationHostedJobsPageName":"lightdash"}}'
+    headers:
+      Content-Type:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jul 2024 17:00:26 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      X-Ashby-Request-Id:
+      - 01J429C1Q3QX6CA10FW5JCG7TM
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - DENY
+      Referrer-Policy:
+      - same-origin
+      Cache-Control:
+      - no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0
+      Access-Control-Allow-Origin:
+      - "*"
+      Cf-Cache-Status:
+      - DYNAMIC
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 8ab6e7aa8fae63c0-LHR
+      Alt-Svc:
+      - h3=":443"; ma=86400
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        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
+  recorded_at: Tue, 30 Jul 2024 17:00:26 GMT
+- request:
+    method: post
+    uri: https://jobs.ashbyhq.com/api/non-user-graphql
+    body:
+      encoding: UTF-8
+      string: '{"query":"query ApiJobPosting($organizationHostedJobsPageName: String!,
+        $jobPostingId: String!) {  jobPosting(    organizationHostedJobsPageName:
+        $organizationHostedJobsPageName    jobPostingId: $jobPostingId  ) {    applicationForm
+        {      ...FormRenderParts      __typename    }    surveyForms {      ...FormRenderParts      __typename    }    applicationDeadline    applicationLimitCalloutHtml    __typename  }}fragment
+        JSONBoxParts on JSONBox {  value  __typename}fragment FileParts on File {  id  filename  __typename}fragment
+        FormFieldEntryParts on FormFieldEntry {  id  field  fieldValue {    ... on
+        JSONBox {      ...JSONBoxParts      __typename    }    ... on File {      ...FileParts      __typename    }    ...
+        on FileList {      files {        ...FileParts        __typename      }      __typename    }    __typename  }  isRequired  descriptionHtml  isHidden  __typename}fragment
+        FormRenderParts on FormRender {  id  formControls {    identifier    title    __typename  }  errorMessages  sections
+        {    title    descriptionHtml    fieldEntries {      ...FormFieldEntryParts      __typename    }    isHidden    __typename  }  sourceFormDefinitionId  __typename}","variables":{"jobPostingId":"9efa292a-cc34-4388-90a2-2bed5126ace4","organizationHostedJobsPageName":"lightdash"}}'
+    headers:
+      Content-Type:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jul 2024 17:00:27 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      X-Ashby-Request-Id:
+      - 01J429C1YBNV1TAMASK0T1DRTQ
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - DENY
+      Referrer-Policy:
+      - same-origin
+      Cache-Control:
+      - no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0
+      Access-Control-Allow-Origin:
+      - "*"
+      Cf-Cache-Status:
+      - DYNAMIC
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 8ab6e7ac1b76368f-LHR
+      Alt-Svc:
+      - h3=":443"; ma=86400
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        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
+  recorded_at: Tue, 30 Jul 2024 17:00:27 GMT
+- request:
+    method: post
+    uri: https://jobs.ashbyhq.com/api/non-user-graphql
+    body:
+      encoding: UTF-8
+      string: '{"query":"query ApiJobPosting($organizationHostedJobsPageName: String!,
+        $jobPostingId: String!) {  jobPosting(    organizationHostedJobsPageName:
+        $organizationHostedJobsPageName    jobPostingId: $jobPostingId  ) {    applicationForm
+        {      ...FormRenderParts      __typename    }    surveyForms {      ...FormRenderParts      __typename    }    applicationDeadline    applicationLimitCalloutHtml    __typename  }}fragment
+        JSONBoxParts on JSONBox {  value  __typename}fragment FileParts on File {  id  filename  __typename}fragment
+        FormFieldEntryParts on FormFieldEntry {  id  field  fieldValue {    ... on
+        JSONBox {      ...JSONBoxParts      __typename    }    ... on File {      ...FileParts      __typename    }    ...
+        on FileList {      files {        ...FileParts        __typename      }      __typename    }    __typename  }  isRequired  descriptionHtml  isHidden  __typename}fragment
+        FormRenderParts on FormRender {  id  formControls {    identifier    title    __typename  }  errorMessages  sections
+        {    title    descriptionHtml    fieldEntries {      ...FormFieldEntryParts      __typename    }    isHidden    __typename  }  sourceFormDefinitionId  __typename}","variables":{"jobPostingId":"9efa292a-cc34-4388-90a2-2bed5126ace4","organizationHostedJobsPageName":"lightdash"}}'
+    headers:
+      Content-Type:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jul 2024 17:00:27 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      X-Ashby-Request-Id:
+      - 01J429C2A83Z88DBQ71DDVZBJA
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - DENY
+      Referrer-Policy:
+      - same-origin
+      Cache-Control:
+      - no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0
+      Access-Control-Allow-Origin:
+      - "*"
+      Cf-Cache-Status:
+      - DYNAMIC
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 8ab6e7ae7f734913-LHR
+      Alt-Svc:
+      - h3=":443"; ma=86400
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        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
+  recorded_at: Tue, 30 Jul 2024 17:00:27 GMT
+- request:
+    method: post
+    uri: https://jobs.ashbyhq.com/api/non-user-graphql
+    body:
+      encoding: UTF-8
+      string: '{"query":"query ApiJobPosting($organizationHostedJobsPageName: String!,
+        $jobPostingId: String!) {  jobPosting(    organizationHostedJobsPageName:
+        $organizationHostedJobsPageName    jobPostingId: $jobPostingId  ) {    applicationForm
+        {      ...FormRenderParts      __typename    }    surveyForms {      ...FormRenderParts      __typename    }    applicationDeadline    applicationLimitCalloutHtml    __typename  }}fragment
+        JSONBoxParts on JSONBox {  value  __typename}fragment FileParts on File {  id  filename  __typename}fragment
+        FormFieldEntryParts on FormFieldEntry {  id  field  fieldValue {    ... on
+        JSONBox {      ...JSONBoxParts      __typename    }    ... on File {      ...FileParts      __typename    }    ...
+        on FileList {      files {        ...FileParts        __typename      }      __typename    }    __typename  }  isRequired  descriptionHtml  isHidden  __typename}fragment
+        FormRenderParts on FormRender {  id  formControls {    identifier    title    __typename  }  errorMessages  sections
+        {    title    descriptionHtml    fieldEntries {      ...FormFieldEntryParts      __typename    }    isHidden    __typename  }  sourceFormDefinitionId  __typename}","variables":{"jobPostingId":"9efa292a-cc34-4388-90a2-2bed5126ace4","organizationHostedJobsPageName":"lightdash"}}'
+    headers:
+      Content-Type:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 30 Jul 2024 17:00:27 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      X-Ashby-Request-Id:
+      - 01J429C2HTDK15VFPXJDEWY3TH
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - DENY
+      Referrer-Policy:
+      - same-origin
+      Cache-Control:
+      - no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0
+      Access-Control-Allow-Origin:
+      - "*"
+      Cf-Cache-Status:
+      - DYNAMIC
+      Strict-Transport-Security:
+      - max-age=31536000; includeSubDomains; preload
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 8ab6e7afd81e63ed-LHR
+      Alt-Svc:
+      - h3=":443"; ma=86400
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        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
+  recorded_at: Tue, 30 Jul 2024 17:00:27 GMT
 recorded_with: VCR 6.2.0